From 776cc63d67ec5c9972240d817253b5d5a6700412 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Mon, 3 Aug 2026 14:26:39 +0000 Subject: [PATCH 01/20] =?UTF-8?q?shard:=20measured-ingress=20Aiur=20planne?= =?UTF-8?q?r=20=E2=80=94=20touch=20graph,=20cost=20model,=20RAM=20packing?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Port of sb/measured-ingress's planning layer onto the addr-first kernel (#529), reworked for its lazy fault-in semantics. Profiling (.ixprof v3): the recording kernel's try_get_const consults are drained per constant into a touch graph — the measured set a lazy checker faults in — persisted as a presence-flagged CSR section alongside a new block-level reference graph and a subst_unique counter (splitmix64-keyed dedup of substitution work items: the post-memoization volume a memoizing executor pays). Both graph sections are optional, so older readers' formats stay decodable by version gate alone. Planner: partition_for_aiur_ram bin-packs to a host-RAM cap with faulted-set byte accounting — under #529 the witness always ships the full closure, but only faulted bytes cost ingress trace rows, so a shard's byte feature is owned ∪ touched(owned) (full reference closure as the over-approximating fallback when no touch graph was recorded). The stub/promotion machinery of the original branch is dropped entirely: lazy fault-in computes at run time exactly the set the stubs predicted, with no replay divergence and no repair ladder, and the manifest format stays byte-identical with main (owned-only). Cost models: nlogn(x) = x·log2(x+2) feature form matching Aiur's width·height·log2(height) FFT structure; prove/execute time and RAM coefficients carried over from the pre-#529 aiur bench-suite fits. They are placeholders pending a refit against this kernel — the circuit shrank (deleted positional machinery), the byte feature narrowed to the faulted set, and the recording counters moved under #442 — with provenance noted at the definitions. The costs sidecar (.costs.csv) persists per-shard features incl. subst_unique and nat_arith so the refit has its corpus. CLI: ix shard --backend aiur --max-ram G; ix profile --backend/--top (per-metric block leaderboards with display names) and ix profile sweep (env-wide closure cost sweep: per-root feature CSV + feasibility, min-root-per-hot-block, and diversity reports). --- Ix/Cli/ProfileCmd.lean | 45 ++- Ix/Cli/ShardCmd.lean | 14 +- Ix/KernelCheck.lean | 28 +- crates/ffi/src/kernel.rs | 646 ++++++++++++++++++++++++++++++++-- crates/kernel/src/profile.rs | 314 +++++++++++++++-- crates/kernel/src/shard.rs | 660 +++++++++++++++++++++++++++++++++-- crates/kernel/src/subst.rs | 16 +- crates/kernel/src/tc.rs | 17 +- 8 files changed, 1651 insertions(+), 89 deletions(-) diff --git a/Ix/Cli/ProfileCmd.lean b/Ix/Cli/ProfileCmd.lean index d42b428b6..aeed2e1c8 100644 --- a/Ix/Cli/ProfileCmd.lean +++ b/Ix/Cli/ProfileCmd.lean @@ -21,6 +21,38 @@ open Ix.KernelCheck namespace Ix.Cli.ProfileCmd +def runSweepCmd (p : Cli.Parsed) : IO UInt32 := do + let some pathArg := p.positionalArg? "path" + | p.printError "error: must specify to a .ixe file" + return 1 + let envPath := pathArg.as! String + let base := if envPath.endsWith ".ixe" then (envPath.dropEnd 4).toString else envPath + let profPath := (p.flag? "prof").map (·.as! String) |>.getD (base ++ ".ixprof") + let csvPath := (p.flag? "out").map (·.as! String) |>.getD (base ++ "-sweep.csv") + let budget := (p.flag? "budget").map (·.as! Nat) |>.getD 64 + let topBlocks := (p.flag? "top-blocks").map (·.as! Nat) |>.getD 10 + let reps := (p.flag? "reps").map (·.as! Nat) |>.getD 10 + IO.println s!"Sweeping {envPath} × {profPath} → {csvPath} (budget {budget} GiB)" + rsProfileSweepFFI envPath profPath csvPath (toString budget) + (toString topBlocks) (toString reps) + IO.println s!"[sweep] wrote {csvPath}" + return 0 + +def sweepCmd : Cli.Cmd := `[Cli| + "sweep" VIA runSweepCmd; + "Closure cost sweep: predicted Aiur execute/prove cost for every named constant's dependency closure, plus feasibility/bottleneck/diversity reports" + + FLAGS: + prof : String; "Input .ixprof from `ix profile` (default: .ixprof)" + out : String; "Output CSV path (default: -sweep.csv)" + budget : Nat; "RAM budget in GiB for the feasibility report (default 64)" + "top-blocks" : Nat; "Expensive blocks tracked for the min-root report (default 10, max 64)" + reps : Nat; "Diverse feature-mix representatives to pick (default 10; 0 disables)" + + ARGS: + path : String; "Path to the serialized .ixe the .ixprof was profiled from" +] + def runProfileCmd (p : Cli.Parsed) : IO UInt32 := do let some pathArg := p.positionalArg? "path" | p.printError "error: must specify to a .ixe file" @@ -44,9 +76,15 @@ def runProfileCmd (p : Cli.Parsed) : IO UInt32 := do return 1 Std.Internal.UV.System.osSetenv "IX_KERNEL_CHECK_WORKERS" (toString n) + let top := (p.flag? "top").map (·.as! Nat) |>.getD 10 + let backend := (p.flag? "backend").map (·.as! String) |>.getD "all" + if backend != "all" && backend != "aiur" && backend != "zisk" then + p.printError s!"error: --backend must be all, aiur, or zisk (got {backend})" + return 1 + IO.println s!"Profiling {envPath} → {outPath} (isolate={isolate})" let start ← IO.monoMsNow - rsProfileAnonFFI envPath outPath isolate quiet + rsProfileAnonFFI envPath outPath isolate quiet (toString top) backend let elapsed := (← IO.monoMsNow) - start IO.println s!"[profile] wrote {outPath} in {elapsed.formatMs}" return 0 @@ -63,9 +101,14 @@ def profileCmd : Cli.Cmd := `[Cli| "keep-caches"; "Keep cross-constant caches: faster, lower-fidelity, may under-record" workers : Nat; "Parallel kernel workers (default: available_parallelism). Plumbs IX_KERNEL_CHECK_WORKERS." verbose; "Log every constant (default: quiet)" + top : Nat; "Block-leaderboard size in the summary: top N by heartbeats, substitutions, ingress bytes, and predicted per-backend cost (default 10; 0 disables)" + backend : String; "Cost models in the summary: all (default), aiur, or zisk" ARGS: path : String; "Path to a serialized .ixe environment" + + SUBCOMMANDS: + sweepCmd ] end diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index 8bdee9638..c3c87f4ae 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -97,21 +97,28 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do match p.flag? "parallelism" with | some flag => max 1 (flag.as! Nat) | none => 1 + let backend := (p.flag? "backend").map (·.as! String) |>.getD "zisk" + if backend != "zisk" && backend != "aiur" then + p.printError s!"error: --backend must be zisk or aiur (got {backend})" + return 1 -- Precedence: explicit --shards (fixed count) > explicit --max-cycles/--max-ram -- (budget) > default (size to detected system RAM). match shardsFlag with | some n => + if backend != "zisk" then + p.printError s!"error: --backend {backend} packs to a RAM budget; use --max-ram, not --shards" + return 1 IO.println s!"Sharding {espPath} into {n} shards (balance ±{balancePct}%)" rsShardEspFFI espPath (toString n) (toString balancePct) (toString parallelism) outPath | none => if maxCycles.isNone && maxRam.isNone then - IO.println s!"Sharding {espPath} to detected system RAM (balance ±{balancePct}%)" + IO.println s!"Sharding {espPath} to detected system RAM ({backend} model, balance ±{balancePct}%)" else - IO.println s!"Sharding {espPath} to budget (max-cycles={maxCycles.getD 0}, max-ram={maxRam.getD 0} GiB, balance ±{balancePct}%)" + IO.println s!"Sharding {espPath} to budget ({backend} model, max-cycles={maxCycles.getD 0}, max-ram={maxRam.getD 0} GiB, balance ±{balancePct}%)" rsShardEspCapFFI espPath (toString (maxCycles.getD 0)) (toString (maxRam.getD 0)) - (toString balancePct) (toString parallelism) outPath + (toString balancePct) (toString parallelism) outPath backend if !outPath.isEmpty then IO.println s!"[shard] wrote {outPath}" return 0 @@ -129,6 +136,7 @@ def shardCmd : Cli.Cmd := `[Cli| "max-ram" : Nat; "Per-shard host-RAM budget, GiB (default: detected system RAM)" balance : Nat; "Per-bisection balance tolerance, percent (default 5)" parallelism : Nat; "Provers assumed for the prove-time estimate (default 1 = sequential)" + backend : String; "Packing cost model: zisk (default, guest-STEP cap) or aiur (RAM model; use with --max-ram)" out : String; "Output .ixes manifest path (default: .ixes, e.g. init.ixprof → init.ixes)" ARGS: diff --git a/Ix/KernelCheck.lean b/Ix/KernelCheck.lean index 5449c0a5c..d8e04c8a8 100644 --- a/Ix/KernelCheck.lean +++ b/Ix/KernelCheck.lean @@ -198,13 +198,34 @@ opaque rsEnvExtractFFI : per-block heartbeats + the delta-unfold graph (the sharding cost model, see `plans/sharding.md`). Runs the anon kernel over every checkable target. `isolate` clears the kernel's reduction-memo caches between constants for - sound/faithful recording; `quiet` suppresses per-constant progress. -/ + sound/faithful recording; `quiet` suppresses per-constant progress. `top` + (a decimal string, kept ABI-simple) sizes the summary's per-metric block + leaderboards; "0" disables them. `backend` selects which cost models the + summary prints: "aiur", "zisk", or "all". -/ @[extern "rs_kernel_profile_anon"] opaque rsProfileAnonFFI : @& String → -- .ixe path @& String → -- .ixprof output path @& Bool → -- isolate caches @& Bool → -- quiet + @& String → -- leaderboard size (decimal) + @& String → -- backend cost models (all|aiur|zisk) + IO Unit + +/-- FFI: env-wide closure cost sweep. For every named constant (one + representative name per home block), walks its full reference closure, + sums the whole-env `.ixprof` per-block counters over the members, and + applies the Aiur execute/prove cost models. Writes a per-root CSV and + prints feasibility / min-root-per-hot-block / diversity reports to + stderr. Numeric params are decimal strings (ABI-simple). -/ +@[extern "rs_profile_sweep"] +opaque rsProfileSweepFFI : + @& String → -- .ixe path + @& String → -- .ixprof path + @& String → -- output CSV path + @& String → -- RAM budget GiB (decimal) + @& String → -- hot blocks tracked (decimal) + @& String → -- diversity representatives (decimal) IO Unit /-- FFI: partition a `.ixprof` into `numShards` shards, writing a `.ixes` @@ -222,7 +243,9 @@ opaque rsShardEspFFI : /-- FFI: partition a `.ixprof` to a per-shard cycle/RAM budget, writing a `.ixes` manifest. `maxCycles` is a guest-STEP cap; if `ramGb` > 0 it is converted via the measured prover RAM model and overrides `maxCycles`. Pass - "0" for whichever is unused. Decimal strings (ABI-simple). -/ + "0" for whichever is unused. Decimal strings (ABI-simple). `backend` + selects the packing cost model: "zisk" (guest-STEP cap) or "aiur" (RAM + model; RAM budgets only). -/ @[extern "rs_shard_esp_cap"] opaque rsShardEspCapFFI : @& String → -- .ixprof path @@ -231,6 +254,7 @@ opaque rsShardEspCapFFI : @& String → -- balance percent @& String → -- parallelism (provers for prove-time est) @& String → -- .ixes output path ("" = skip) + @& String → -- backend cost model (zisk|aiur) IO Unit end Ix.KernelCheck diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index f548a1bae..9d32294c6 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -69,7 +69,9 @@ use ix_kernel::ingress::{ #[cfg(feature = "test-ffi")] use ix_kernel::ingress::{ixon_ingress, lean_ingress}; use ix_kernel::mode::{Anon, CheckDupLevelParams, KernelMode, Meta}; -use ix_kernel::profile::{BlockProfile, OpCounts, ProfileBuilder, ProfileSink}; +use ix_kernel::profile::{ + BlockEntry, BlockProfile, OpCounts, ProfileBuilder, ProfileSink, +}; use ix_kernel::tc::TypeChecker; use ixon::constant::ConstantInfo as IxonCI; #[cfg(feature = "test-ffi")] @@ -2240,20 +2242,478 @@ fn profile_block_size(env: &IxonEnv, block: &Address) -> u32 { // `steps as f64` is a display-only cast for `{:.2e}` formatting; precision loss // past 2⁵³ steps is irrelevant to a two-sig-fig estimate. #[allow(clippy::cast_precision_loss)] +/// Display name per profile block: the lexicographically-smallest named +/// member (constants resolve through `profile_block_of`, so a projection's +/// name lands on its block; a directly-named `Muts` block keeps its own +/// `…._mutual`-style name). Smallest-wins keeps the pick deterministic. +/// The anon env carries no names (`get_anon_mmap` stops before §4-6), so +/// the §5 entries are re-read from the file via the lazy index — cheap: +/// the lazy parser skips constant and metadata bodies. Any read/parse +/// failure just yields an empty map (the leaderboards fall back to +/// addresses); names are presentation, never worth failing the profile. +fn block_display_names( + env: &IxonEnv, + path: &str, +) -> FxHashMap { + let Ok(bytes) = std::fs::read(path) else { + return FxHashMap::default(); + }; + let Ok(index) = IxonEnv::parse_lazy_index(&bytes) else { + return FxHashMap::default(); + }; + let mut names: FxHashMap = FxHashMap::default(); + // Compiler-generated `Ix.<64-hex>.…` aux aliases sort before every human + // name; prefer any human name over them, then smallest-wins. + let is_aux = |s: &str| { + s.strip_prefix("Ix.").is_some_and(|r| { + r.len() > 65 + && r.as_bytes()[64] == b'.' + && r.as_bytes()[..64].iter().all(u8::is_ascii_hexdigit) + }) + }; + let rank = |s: &str| (is_aux(s), s.to_owned()); + for ln in &index.named { + let block = profile_block_of(env, &ln.addr); + let s = format!("{}", ln.name); + names + .entry(block) + .and_modify(|cur| { + if rank(&s) < rank(cur) { + *cur = s.clone(); + } + }) + .or_insert(s); + } + names +} + +/// Print the top-`n` blocks by one metric, largest first, with display +/// names (falling back to the block address) and the block's member count. +fn print_top_blocks( + title: &str, + n: usize, + profile: &BlockProfile, + names: &FxHashMap, + metric: &dyn Fn(&BlockEntry) -> u64, +) { + let blocks = profile.blocks(); + let mut idx: Vec = (0..blocks.len()).collect(); + idx.sort_by_key(|&i| std::cmp::Reverse(metric(&blocks[i]))); + eprintln!("\n top {} blocks by {title}", n.min(blocks.len())); + for (rank, &i) in idx.iter().take(n).enumerate() { + let b = &blocks[i]; + let name = names.get(&b.addr).cloned().unwrap_or_else(|| b.addr.hex()); + let members = if b.const_count > 1 { + format!(" [{} consts]", b.const_count) + } else { + String::new() + }; + eprintln!(" {:>2}. {:>14} {name}{members}", rank + 1, metric(b)); + } +} + +/// Block-level reference adjacency for a profiled env: for each block, the +/// sorted, deduped, self-edge-free set of blocks it references. Projection +/// and mutual-member edges are intra-block by construction, so per-constant +/// `refs` folded to home blocks carry every cross-block edge of +/// `Env::bfs_closure`. This is the graph persisted into the `.ixprof` +/// (reachability over it = a block's full dependency closure — what an Aiur +/// shard's witness ships) and the sweep's walk graph. +fn build_block_ref_adjacency( + env: &IxonEnv, + profile: &BlockProfile, +) -> Vec> { + let blocks = profile.blocks(); + let n = blocks.len(); + let id_of: FxHashMap<&Address, u32> = blocks + .iter() + .enumerate() + .filter_map(|(i, b)| u32::try_from(i).ok().map(|id| (&b.addr, id))) + .collect(); + // Pass 1: every constant's home block id. + let mut home: FxHashMap = FxHashMap::default(); + for entry in env.consts.iter() { + let (addr, lazy) = (entry.key(), entry.value()); + let Ok(c) = lazy.get() else { continue }; + let home_addr = match &c.info { + IxonCI::IPrj(p) => &p.block, + IxonCI::CPrj(p) => &p.block, + IxonCI::RPrj(p) => &p.block, + IxonCI::DPrj(p) => &p.block, + _ => addr, + }; + if let Some(&id) = id_of.get(home_addr) { + home.insert(addr.clone(), id); + } + } + // Pass 2: fold each constant's refs to home-block edges. + let mut adj: Vec> = vec![Vec::new(); n]; + for entry in env.consts.iter() { + let (addr, lazy) = (entry.key(), entry.value()); + let Ok(c) = lazy.get() else { continue }; + let Some(&hid) = home.get(addr) else { continue }; + for r in &c.refs { + if let Some(&rid) = home.get(r) + && rid != hid + { + adj[hid as usize].push(rid); + } + } + } + for row in &mut adj { + row.sort_unstable(); + row.dedup(); + } + adj +} + +/// One root's closure-aggregated features + model predictions, as produced by +/// [`profile_sweep`]. +struct SweepRow { + name: String, + closure_blocks: u32, + bytes: u64, + hb: u64, + subst: u64, + subst_unique: u64, + whnf: u64, + def_eq: u64, + nat_arith: u64, + exec_s: f64, + exec_gib: f64, + prove_s: f64, + prove_gib: f64, + /// Membership mask over the sweep's tracked expensive blocks (bit `j` set ⇔ + /// this closure contains tracked block `j`). + hot_mask: u64, +} + +/// Env-wide closure cost sweep: for every named constant (one representative +/// name per home block), walk its full reference closure over the env's +/// constant graph, sum the whole-env profile's per-block counters over the +/// members, and apply the Aiur execute/prove models. One kernel profile run +/// amortizes over every query — nothing here re-checks or re-serializes. +/// +/// The closure is REFERENCE reachability (`Constant.refs`, with projections +/// folded into their home blocks), matching `ix shard extract`'s membership — +/// not the `.ixprof` delta graph, which under-approximates it (a constant can +/// be referenced but never delta-unfolded). Summing whole-env per-block +/// counters over the membership equals a fresh per-closure profile because +/// isolate-mode counters are per-block context-free. +/// +/// Reports, beyond the per-root CSV: +/// - feasibility at `budget_gib`: counts + the cheapest prove-infeasible +/// closures (minimal reproducers of the RAM bottleneck); +/// - min-root per hot block: for each of the `top_m` most expensive blocks +/// (by marginal Aiur prove cost), the cheapest closure containing it; +/// - `reps_k` diversity picks: prove-feasible closures with maximally +/// distinct feature mixes (farthest-point sampling, seeded on the highest +/// nat-arith share — the model's blind-spot axis). +#[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)] +pub fn profile_sweep( + env_path: &str, + prof_path: &str, + csv_out: &str, + budget_gib: f64, + top_m: usize, + reps_k: usize, +) -> Result { + use ix_kernel::shard::{ + AIUR_RAM_USABLE_FRAC, aiur_block_prove_secs, aiur_exec_ram_gib, + aiur_exec_secs, aiur_prove_secs, aiur_ram_gib, + }; + use rayon::prelude::*; + + let t0 = Instant::now(); + let env = IxonEnv::get_anon_mmap(std::path::Path::new(env_path)) + .map_err(|e| format!("sweep: mmap+deserialize {env_path}: {e}"))?; + let prof_bytes = std::fs::read(prof_path) + .map_err(|e| format!("sweep: read {prof_path}: {e}"))?; + let mut profile = BlockProfile::from_bytes(&prof_bytes) + .map_err(|e| format!("sweep: parse {prof_path}: {e}"))?; + if !profile.has_ref_graph() { + let adj = build_block_ref_adjacency(&env, &profile); + profile.set_ref_graph(&adj); + } + let blocks = profile.blocks(); + let n = blocks.len(); + let id_of: FxHashMap<&Address, u32> = + blocks.iter().enumerate().map(|(i, b)| (&b.addr, i as u32)).collect(); + + // Roots: one representative (lexicographically-smallest) name per block. + let names = block_display_names(&env, env_path); + let mut roots: Vec<(String, u32)> = names + .iter() + .filter_map(|(a, s)| id_of.get(a).map(|&id| (s.clone(), id))) + .collect(); + roots.sort(); + eprintln!( + "[sweep] {} blocks, {} roots ({:.1?} setup)", + n, + roots.len(), + t0.elapsed() + ); + + // Hot blocks to track membership for: top `top_m` by marginal prove cost. + let top_m = top_m.min(64); + let mut hot: Vec = (0..n).collect(); + hot.sort_by(|&a, &b| { + aiur_block_prove_secs(&blocks[b]) + .total_cmp(&aiur_block_prove_secs(&blocks[a])) + }); + hot.truncate(top_m); + let mut hot_bit = vec![u64::MAX; n]; // MAX = not tracked + for (j, &b) in hot.iter().enumerate() { + hot_bit[b] = j as u64; + } + + // Per-root BFS with an epoch-marked visited array per rayon worker. + let sweep_start = Instant::now(); + let rows: Vec = roots + .par_iter() + .map_init( + || (vec![0u32; n], 0u32, Vec::::new()), + |(visited, epoch, stack), (name, root)| { + *epoch += 1; + stack.clear(); + stack.push(*root); + visited[*root as usize] = *epoch; + let (mut cb, mut bytes, mut hb, mut subst, mut uniq) = + (0u32, 0u64, 0u64, 0u64, 0u64); + let (mut whnf, mut def_eq, mut nat) = (0u64, 0u64, 0u64); + let mut hot_mask = 0u64; + while let Some(b) = stack.pop() { + let e = &blocks[b as usize]; + cb += 1; + bytes += u64::from(e.serialized_size); + hb += e.heartbeats; + subst += e.subst; + uniq += e.subst_unique; + whnf += e.whnf; + def_eq += e.def_eq; + nat += e.nat_arith; + if hot_bit[b as usize] != u64::MAX { + hot_mask |= 1 << hot_bit[b as usize]; + } + for &r in profile.refs(b) { + if visited[r as usize] != *epoch { + visited[r as usize] = *epoch; + stack.push(r); + } + } + } + SweepRow { + name: name.clone(), + closure_blocks: cb, + bytes, + hb, + subst, + subst_unique: uniq, + whnf, + def_eq, + nat_arith: nat, + exec_s: aiur_exec_secs(bytes, subst), + exec_gib: aiur_exec_ram_gib(bytes), + prove_s: aiur_prove_secs(bytes, subst), + prove_gib: aiur_ram_gib(bytes, hb), + hot_mask, + } + }, + ) + .collect(); + eprintln!( + "[sweep] {} closures walked in {:.1?}", + rows.len(), + sweep_start.elapsed() + ); + + // CSV (quote names defensively; Lean names can contain most anything). + let mut csv = String::with_capacity(rows.len() * 96); + csv.push_str( + "name,closure_blocks,bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,\ + exec_s,exec_ram_gib,prove_s,prove_ram_gib\n", + ); + for r in &rows { + let quoted = if r.name.contains(',') || r.name.contains('"') { + format!("\"{}\"", r.name.replace('"', "\"\"")) + } else { + r.name.clone() + }; + csv.push_str(&format!( + "{},{},{},{},{},{},{},{},{},{:.3},{:.2},{:.3},{:.2}\n", + quoted, + r.closure_blocks, + r.bytes, + r.hb, + r.subst, + r.subst_unique, + r.whnf, + r.def_eq, + r.nat_arith, + r.exec_s, + r.exec_gib, + r.prove_s, + r.prove_gib, + )); + } + std::fs::write(csv_out, &csv).map_err(|e| format!("write {csv_out}: {e}"))?; + + // ── Report 1: feasibility at the budget ── + let cap = budget_gib * AIUR_RAM_USABLE_FRAC; + let exec_ok = rows.iter().filter(|r| r.exec_gib <= cap).count(); + let prove_ok = rows.iter().filter(|r| r.prove_gib <= cap).count(); + let total = rows.len(); + let usable_pct = AIUR_RAM_USABLE_FRAC * 100.0; + let mut report = format!( + "sweep: {total} roots → {csv_out}\n\ + feasibility at {budget_gib:.0} GiB (cap {cap:.1} at {usable_pct:.0}% usable): \ + executable {exec_ok}/{total}, provable {prove_ok}/{total}\n\ + cheapest prove-infeasible closures (minimal bottleneck reproducers):\n", + ); + let mut infeasible: Vec<&SweepRow> = + rows.iter().filter(|r| r.prove_gib > cap).collect(); + infeasible.sort_by(|a, b| a.prove_gib.total_cmp(&b.prove_gib)); + for r in infeasible.iter().take(15) { + report.push_str(&format!( + " {:>7.1} GiB {:>8.1} s [{} blocks] {}\n", + r.prove_gib, r.prove_s, r.closure_blocks, r.name + )); + } + + // ── Report 2: cheapest closure containing each hot block ── + let names_by_id: Vec<&str> = (0..n) + .map(|i| names.get(&blocks[i].addr).map_or("", String::as_str)) + .collect(); + report.push_str( + "min-root per expensive block (cheapest closure containing it):\n", + ); + for (j, &b) in hot.iter().enumerate() { + let best = rows + .iter() + .filter(|r| r.hot_mask & (1 << j) != 0) + .min_by(|a, x| a.prove_s.total_cmp(&x.prove_s)); + match best { + Some(r) => report.push_str(&format!( + " {:>8.1} s marginal {:>8.1} s closure {} ⇐ {}\n", + aiur_block_prove_secs(&blocks[b]), + r.prove_s, + names_by_id[b], + r.name, + )), + None => report.push_str(&format!( + " {:>8.1} s marginal {} ⇐ (no named closure reaches it)\n", + aiur_block_prove_secs(&blocks[b]), + names_by_id[b], + )), + } + } + + // ── Report 3: diverse feature-mix representatives (prove-feasible) ── + if reps_k > 0 { + let cands: Vec<&SweepRow> = rows + .iter() + .filter(|r| r.prove_gib <= cap && r.closure_blocks > 1) + .collect(); + if !cands.is_empty() { + let mix = |r: &SweepRow| -> [f64; 4] { + // Feature shares on comparable scales (weights are the models' + // nlogn slopes at a common magnitude, folded to a unit simplex). + let v = [ + r.bytes as f64, + r.hb as f64 * 20.0, + r.subst as f64, + r.nat_arith as f64 * 100.0, + ]; + let s: f64 = v.iter().sum::().max(1.0); + [v[0] / s, v[1] / s, v[2] / s, v[3] / s] + }; + let dist = |a: &[f64; 4], b: &[f64; 4]| -> f64 { + a.iter().zip(b).map(|(x, y)| (x - y) * (x - y)).sum() + }; + // Seed: highest nat-arith share (the blind-spot axis). + let mut picked: Vec = vec![ + (0..cands.len()) + .max_by(|&a, &b| mix(cands[a])[3].total_cmp(&mix(cands[b])[3])) + .unwrap_or(0), + ]; + while picked.len() < reps_k.min(cands.len()) { + let next = + (0..cands.len()).filter(|i| !picked.contains(i)).max_by(|&a, &b| { + let da = picked + .iter() + .map(|&p| dist(&mix(cands[a]), &mix(cands[p]))) + .fold(f64::INFINITY, f64::min); + let db = picked + .iter() + .map(|&p| dist(&mix(cands[b]), &mix(cands[p]))) + .fold(f64::INFINITY, f64::min); + da.total_cmp(&db) + }); + match next { + Some(i) => picked.push(i), + None => break, + } + } + report.push_str( + "diverse prove-feasible representatives (bytes/hb/subst/nat mix):\n", + ); + for &i in &picked { + let r = cands[i]; + let m = mix(r); + report.push_str(&format!( + " {:>6.1} s {:>6.1} GiB mix [{:.2} {:.2} {:.2} {:.2}] {}\n", + r.prove_s, r.prove_gib, m[0], m[1], m[2], m[3], r.name + )); + } + } + } + Ok(report) +} + +/// Which backend cost models the `ix profile` summary prints. +#[derive(Clone, Copy, PartialEq, Eq)] +enum ProfileBackend { + All, + Aiur, + Zisk, +} + +impl ProfileBackend { + fn parse(s: &str) -> Self { + match s { + "aiur" => Self::Aiur, + "zisk" => Self::Zisk, + _ => Self::All, + } + } +} + +/// Print the general-purpose cost breakdown for `ix profile` — the kernel-work +/// metrics plus the predicted per-backend cost/RAM (`backend` selects Aiur, +/// Zisk, or both) and, when `top_n > 0`, per-metric block leaderboards. +// `steps as f64` is a display-only cast for `{:.2e}` formatting; precision loss +// past 2⁵³ steps is irrelevant to a two-sig-fig estimate. +#[allow(clippy::cast_precision_loss)] +#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // ms display fn print_profile_summary( env_path: &str, sink: &ProfileSink, profile: &BlockProfile, + env: &IxonEnv, + top_n: usize, + backend: ProfileBackend, ) { use ix_kernel::shard::{ COST_PER_DEF_EQ, COST_PER_INGRESS_BYTE, COST_PER_INTERN, COST_PER_SUBST, - COST_PER_WHNF, SHARD_COST_FLOOR, block_step_cost, ram_gib_for_steps, + COST_PER_WHNF, SHARD_COST_FLOOR, aiur_block_prove_secs, aiur_prove_secs, + aiur_ram_gib, block_step_cost, ram_gib_for_steps, }; - let (mut hb, mut subst, mut whnf, mut defeq, mut nat, mut intern) = - (0u64, 0u64, 0u64, 0u64, 0u64, 0u64); + let (mut hb, mut subst, mut uniq, mut whnf, mut defeq, mut nat, mut intern) = + (0u64, 0u64, 0u64, 0u64, 0u64, 0u64, 0u64); for rec in sink.records.values() { hb = hb.saturating_add(rec.fuel); subst = subst.saturating_add(rec.ops.subst_nodes); + uniq = uniq.saturating_add(rec.ops.subst_unique); whnf = whnf.saturating_add(rec.ops.whnf_calls); defeq = defeq.saturating_add(rec.ops.def_eq_calls); nat = nat.saturating_add(rec.ops.nat_arith); @@ -2261,35 +2721,85 @@ fn print_profile_summary( } let ingress: u64 = profile.blocks().iter().map(|b| u64::from(b.serialized_size)).sum(); - let steps: u64 = profile - .blocks() - .iter() - .map(block_step_cost) - .fold(SHARD_COST_FLOOR, u64::saturating_add); - let ram_gib = ram_gib_for_steps(steps); - let warn = if ram_gib > 250.0 { - " → exceeds a 250 GiB box; shard it (ix shard --max-ram G)" - } else { - "" - }; eprintln!( "\n── ix profile: {env_path} ──\n\ constants {} blocks {}\n\n\ kernel work\n\ \u{20}\u{20}heartbeats {hb:>14}\n\ \u{20}\u{20}subst nodes {subst:>14}\n\ + \u{20}\u{20}uniq subst {uniq:>14}\n\ \u{20}\u{20}whnf calls {whnf:>14}\n\ \u{20}\u{20}def-eq calls {defeq:>14}\n\ \u{20}\u{20}nat-arith {nat:>14}\n\ \u{20}\u{20}intern nodes {intern:>14}\n\ - \u{20}\u{20}ingress bytes {ingress:>14}\n\n\ - predicted Zisk leaf ({SHARD_COST_FLOOR} + {COST_PER_SUBST}·subst + {COST_PER_WHNF}·whnf + {COST_PER_DEF_EQ}·def_eq + {COST_PER_INTERN}·intern; cross-shard + {COST_PER_INGRESS_BYTE}·bytes)\n\ - \u{20}\u{20}cost units ≈ {:.2e} (~92.5/guest step)\n\ - \u{20}\u{20}RAM ≈ {ram_gib:.0} GiB{warn}", + \u{20}\u{20}ingress bytes {ingress:>14}", sink.records.len(), profile.num_blocks(), - steps as f64, ); + if backend != ProfileBackend::Zisk { + // Whole-env single-run prediction; large envs exceed any real box and + // need `ix shard --backend aiur --max-ram G`. + let prove_s = aiur_prove_secs(ingress, subst); + let ram = aiur_ram_gib(ingress, hb); + let warn = if ram > 250.0 { + " → exceeds a 250 GiB box; shard it (ix shard --backend aiur --max-ram G)" + } else { + "" + }; + eprintln!( + "\n predicted Aiur single run (calibrated on the aiur bench suite; \ + limb-arithmetic-heavy work under-predicts)\n\ + \u{20}\u{20}prove ≈ {prove_s:.1} s\n\ + \u{20}\u{20}RAM ≈ {ram:.0} GiB{warn}" + ); + } + if backend != ProfileBackend::Aiur { + let steps: u64 = profile + .blocks() + .iter() + .map(block_step_cost) + .fold(SHARD_COST_FLOOR, u64::saturating_add); + let ram_gib = ram_gib_for_steps(steps); + let warn = if ram_gib > 250.0 { + " → exceeds a 250 GiB box; shard it (ix shard --max-ram G)" + } else { + "" + }; + eprintln!( + "\n predicted Zisk leaf ({SHARD_COST_FLOOR} + {COST_PER_SUBST}·subst + {COST_PER_WHNF}·whnf + {COST_PER_DEF_EQ}·def_eq + {COST_PER_INTERN}·intern; cross-shard + {COST_PER_INGRESS_BYTE}·bytes)\n\ + \u{20}\u{20}cost units ≈ {:.2e} (~92.5/guest step)\n\ + \u{20}\u{20}RAM ≈ {ram_gib:.0} GiB{warn}", + steps as f64, + ); + } + if top_n > 0 { + let names = block_display_names(env, env_path); + print_top_blocks("heartbeats", top_n, profile, &names, &|b| b.heartbeats); + print_top_blocks("substitution nodes", top_n, profile, &names, &|b| { + b.subst + }); + print_top_blocks("ingress bytes", top_n, profile, &names, &|b| { + u64::from(b.serialized_size) + }); + if backend != ProfileBackend::Zisk { + print_top_blocks( + "predicted Aiur prove ms (marginal)", + top_n, + profile, + &names, + &|b| (aiur_block_prove_secs(b) * 1e3) as u64, + ); + } + if backend != ProfileBackend::Aiur { + print_top_blocks( + "predicted Zisk cost units (sharding cost)", + top_n, + profile, + &names, + &block_step_cost, + ); + } + } } /// Aggregate per-constant records into a block-level [`BlockProfile`]: map each @@ -2317,6 +2827,17 @@ fn build_block_profile(env: &IxonEnv, merged: &ProfileSink) -> BlockProfile { builder.block(pblock.clone(), 0, psize, 0, OpCounts::default()); builder.delta_edge(cblock.clone(), pblock); } + // Touched sets may contain addresses outside the env (synthetic + // entries the checker consults); only env constants have a home block + // to attribute the touch to. + for t in &rec.touched { + if env.get_const(t).is_none() { + continue; + } + let (tblock, tsize) = resolve(t); + builder.block(tblock.clone(), 0, tsize, 0, OpCounts::default()); + builder.touch_edge(cblock.clone(), tblock); + } } builder.finish() } @@ -2428,6 +2949,8 @@ pub fn profile_anon_ixe( out: &str, isolate: bool, quiet: bool, + top_n: usize, + backend: &str, ) -> Result { let load_start = Instant::now(); let ixon_env = IxonEnv::get_anon_mmap(std::path::Path::new(path)) @@ -2449,8 +2972,21 @@ pub fn profile_anon_ixe( failed, run_start.elapsed() ); - let profile = build_block_profile(&env_arc, &merged); - print_profile_summary(path, &merged, &profile); + let mut profile = build_block_profile(&env_arc, &merged); + // Record the block-level reference graph so downstream planners can do + // closure accounting offline: an Aiur shard's witness ships its owned + // blocks' full reference closure, which only this graph can reproduce + // (and it is the fallback byte accounting when no touch graph exists). + let adj = build_block_ref_adjacency(&env_arc, &profile); + profile.set_ref_graph(&adj); + print_profile_summary( + path, + &merged, + &profile, + &env_arc, + top_n, + ProfileBackend::parse(backend), + ); let bytes = profile.to_bytes(); std::fs::write(out, &bytes).map_err(|e| format!("write {out}: {e}"))?; eprintln!( @@ -2476,12 +3012,18 @@ pub extern "C" fn rs_kernel_profile_anon( out_path: LeanString>, isolate: LeanBool>, quiet: LeanBool>, + top: LeanString>, + backend: LeanString>, ) -> LeanIOResult { + // Decimal string, kept ABI-simple like `rs_shard_esp`'s numeric params. + let top_n = top.to_string().parse::().unwrap_or(10); match profile_anon_ixe( &env_path.to_string(), &out_path.to_string(), isolate.to_bool(), quiet.to_bool(), + top_n, + &backend.to_string(), ) { Ok(s) => { eprintln!( @@ -2496,6 +3038,37 @@ pub extern "C" fn rs_kernel_profile_anon( } } +/// FFI: env-wide closure cost sweep (see [`profile_sweep`]). Writes the +/// per-root CSV and prints the feasibility/min-root/diversity reports to +/// stderr. Numeric params are decimal strings (ABI-simple). +#[unsafe(no_mangle)] +pub extern "C" fn rs_profile_sweep( + env_path: LeanString>, + prof_path: LeanString>, + csv_path: LeanString>, + budget_gib: LeanString>, + top_blocks: LeanString>, + reps: LeanString>, +) -> LeanIOResult { + let budget = budget_gib.to_string().parse::().unwrap_or(64.0); + let top_m = top_blocks.to_string().parse::().unwrap_or(10); + let reps_k = reps.to_string().parse::().unwrap_or(10); + match profile_sweep( + &env_path.to_string(), + &prof_path.to_string(), + &csv_path.to_string(), + budget, + top_m, + reps_k, + ) { + Ok(report) => { + eprintln!("[rs_sweep]\n{report}"); + LeanIOResult::ok(LeanOwned::box_usize(0)) + }, + Err(e) => LeanIOResult::error_string(&format!("rs_profile_sweep: {e}")), + } +} + /// FFI: partition a `.ixprof` into `num_shards` shards and write a `.ixes` /// manifest. Prints a what-if report to stderr. #[allow(clippy::cast_precision_loss)] // balance_pct is a small percentage @@ -2540,7 +3113,10 @@ fn system_ram_gib() -> Option { /// FFI: partition a `.ixprof` to a per-shard cycle/RAM budget and write a /// `.ixes` manifest. `max_cycles` is a guest-STEP cap; if `ram_gb` > 0 it is /// converted via the measured prover RAM model and overrides `max_cycles`. Pass -/// "0" for both to default the budget to detected system RAM. +/// "0" for both to default the budget to detected system RAM. `backend` +/// selects the cost model: "zisk" (default) packs to the guest-STEP cap, +/// "aiur" packs to the Aiur RAM model (RAM budgets only — a cycle cap is a +/// Zisk-specific unit). #[allow(clippy::cast_precision_loss)] #[unsafe(no_mangle)] pub extern "C" fn rs_shard_esp_cap( @@ -2550,6 +3126,7 @@ pub extern "C" fn rs_shard_esp_cap( balance_pct: LeanString>, parallelism: LeanString>, out_path: LeanString>, + backend: LeanString>, ) -> LeanIOResult { let mc = max_cycles.to_string().parse::().unwrap_or(0); let mut ram = ram_gb.to_string().parse::().unwrap_or(0.0); @@ -2557,6 +3134,7 @@ pub extern "C" fn rs_shard_esp_cap( parallelism.to_string().parse::().unwrap_or(1).max(1); let balance = (balance_pct.to_string().parse::().unwrap_or(5) as f64) / 100.0; + let aiur = backend.to_string() == "aiur"; // No explicit cap → default the RAM budget to detected system RAM. if mc == 0 && ram <= 0.0 { match system_ram_gib() { @@ -2573,6 +3151,28 @@ pub extern "C" fn rs_shard_esp_cap( }, } } + if aiur { + if ram <= 0.0 { + return LeanIOResult::error_string( + "shard --backend aiur sizes by RAM; pass --max-ram G (a cycle cap is a Zisk unit)", + ); + } + let out = out_path.to_string(); + let out_opt = if out.is_empty() { None } else { Some(out.as_str()) }; + return match ix_kernel::shard::shard_esp_aiur( + &esp_path.to_string(), + ram, + balance, + parallelism, + out_opt, + ) { + Ok(report) => { + eprintln!("[rs_shard]\n{report}"); + LeanIOResult::ok(LeanOwned::box_usize(0)) + }, + Err(e) => LeanIOResult::error_string(&format!("rs_shard_esp_cap: {e}")), + }; + } let cap = if ram > 0.0 { ix_kernel::shard::cycle_cap_for_ram(ram) } else { mc }; if cap == 0 { diff --git a/crates/kernel/src/profile.rs b/crates/kernel/src/profile.rs index 1fb71613e..7d8b881e4 100644 --- a/crates/kernel/src/profile.rs +++ b/crates/kernel/src/profile.rs @@ -53,6 +53,10 @@ use ix_common::address::Address; #[cfg(not(target_os = "zkvm"))] thread_local! { static SUBST_NODES: Cell = const { Cell::new(0) }; + static SUBST_UNIQUE: Cell = const { Cell::new(0) }; + static SUBST_CTX: Cell = const { Cell::new(0) }; + static SUBST_SEEN: std::cell::RefCell> = + std::cell::RefCell::new(FxHashSet::default()); static WHNF_CALLS: Cell = const { Cell::new(0) }; static DEF_EQ_CALLS: Cell = const { Cell::new(0) }; static NAT_ARITH: Cell = const { Cell::new(0) }; @@ -66,6 +70,48 @@ pub fn bump_subst_nodes() { SUBST_NODES.with(|c| c.set(c.get().wrapping_add(1))); } +/// Set the substitution-context component of the unique-work key: a fold +/// of the substitution arguments' identities, computed once per top-level +/// `instantiate_rev` call (the recursion never re-enters subst, so one +/// slot suffices). Mixed into every node key by [`bump_subst_unique`]. +#[inline(always)] +pub fn set_subst_ctx(ctx: u64) { + #[cfg(not(target_os = "zkvm"))] + SUBST_CTX.with(|c| c.set(ctx)); + #[cfg(target_os = "zkvm")] + let _ = ctx; +} + +/// Count one substitution-node visit deduplicated by its work identity: +/// (expression `expr_key`, binder `depth`, the current substitution +/// context from [`set_subst_ctx`]). A memoizing executor (Aiur proves +/// each unique query once; repeats are memo-table lookups) pays only for +/// distinct work, so `subst_unique`, not the raw visit count, is the +/// substitution-volume feature for an Aiur cost model. The seen-set +/// spans one constant's check — the same scope as the other counters +/// (cleared by [`take_op_counts`]). +#[inline(always)] +pub fn bump_subst_unique(expr_key: u64, depth: u64) { + #[cfg(not(target_os = "zkvm"))] + { + // splitmix64 finalizer over the mixed triple — collisions only cost + // model accuracy, never soundness. + let mut k = expr_key + ^ SUBST_CTX.with(Cell::get) + ^ depth.wrapping_mul(0x9E37_79B9_7F4A_7C15); + k = (k ^ (k >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + k = (k ^ (k >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + k ^= k >> 31; + SUBST_SEEN.with(|s| { + if s.borrow_mut().insert(k) { + SUBST_UNIQUE.with(|c| c.set(c.get().wrapping_add(1))); + } + }); + } + #[cfg(target_os = "zkvm")] + let _ = (expr_key, depth); +} + /// Count one `whnf` entry. #[inline(always)] pub fn bump_whnf() { @@ -106,6 +152,9 @@ pub fn bump_intern_nodes() { #[derive(Default, Debug, Clone, Copy)] pub struct OpCounts { pub subst_nodes: u64, + /// Distinct substitution work items (see [`bump_subst_unique`]) — the + /// post-memoization substitution volume a memoizing executor pays. + pub subst_unique: u64, pub whnf_calls: u64, pub def_eq_calls: u64, pub nat_arith: u64, @@ -116,6 +165,7 @@ impl OpCounts { /// Saturating field-wise accumulation. pub fn add(&mut self, o: &OpCounts) { self.subst_nodes = self.subst_nodes.saturating_add(o.subst_nodes); + self.subst_unique = self.subst_unique.saturating_add(o.subst_unique); self.whnf_calls = self.whnf_calls.saturating_add(o.whnf_calls); self.def_eq_calls = self.def_eq_calls.saturating_add(o.def_eq_calls); self.nat_arith = self.nat_arith.saturating_add(o.nat_arith); @@ -127,8 +177,10 @@ impl OpCounts { pub fn take_op_counts() -> OpCounts { #[cfg(not(target_os = "zkvm"))] { + SUBST_SEEN.with(|s| s.borrow_mut().clear()); OpCounts { subst_nodes: SUBST_NODES.with(|c| c.replace(0)), + subst_unique: SUBST_UNIQUE.with(|c| c.replace(0)), whnf_calls: WHNF_CALLS.with(|c| c.replace(0)), def_eq_calls: DEF_EQ_CALLS.with(|c| c.replace(0)), nat_arith: NAT_ARITH.with(|c| c.replace(0)), @@ -142,7 +194,7 @@ pub fn take_op_counts() -> OpCounts { /// Magic bytes at the head of every `.ixprof` file. const MAGIC: &[u8; 8] = b"IXPROF\0\0"; /// On-disk format version. Bump on any incompatible layout change. -const VERSION: u32 = 2; +const VERSION: u32 = 3; /// Per-block recorded statistics. #[derive(Clone, Debug, PartialEq, Eq)] @@ -159,6 +211,10 @@ pub struct BlockEntry { /// dominant reduction-volume cost driver. Recorded when profiled with op /// counters enabled; 0 otherwise. pub subst: u64, + /// Distinct substitution work items checking this block — the + /// post-memoization substitution volume (see `bump_subst_unique`); + /// the Aiur-relevant counterpart of `subst`. + pub subst_unique: u64, /// `whnf` entries checking this block (counted before cache probes). pub whnf: u64, /// `is_def_eq` entries checking this block. @@ -182,6 +238,27 @@ pub struct BlockProfile { delta_row: Vec, /// CSR column indices: producer block ids, grouped by consumer. delta_col: Vec, + /// CSR row offsets into `ref_col`, length `blocks.len() + 1`. The + /// **reference** graph (every cross-block `Constant.refs` edge, projections + /// and mutual members folded into home blocks) — a superset of the delta + /// graph. Reachability over it is a block's full dependency closure, which + /// is what an Aiur shard witness ships (`witness_scope` is the owned + /// blocks' whole closure), so the Aiur packer's byte accounting runs on + /// this graph, not the delta graph. + ref_row: Vec, + /// CSR column indices: referenced block ids, grouped by referrer. + ref_col: Vec, + /// CSR row offsets into `touch_col`, length `blocks.len() + 1`. + /// + /// The **touch** graph: blocks whose constants the kernel CONSULTED + /// (`try_get_const`) while checking each block's members — whether a body + /// was unfolded or only a type read. Unlike the delta and reference + /// graphs this is a *measurement* of the ingress a lazy checker demands, + /// not a prediction from graph structure: it is the set the check + /// actually faulted in. Self-edges dropped; recorded per profiling run. + touch_row: Vec, + /// CSR column indices: touched block ids, grouped by consumer. + touch_col: Vec, } impl BlockProfile { @@ -243,11 +320,59 @@ impl BlockProfile { self.blocks.iter().map(|b| u128::from(b.heartbeats)).sum() } + /// Whether the reference graph is present (older recordings may lack it). + pub fn has_ref_graph(&self) -> bool { + !self.ref_row.is_empty() + } + + /// Referenced block ids of block `b` (sorted, deduped, no self-edges). + /// Empty when no reference graph was recorded. + pub fn refs(&self, b: u32) -> &[u32] { + if self.ref_row.is_empty() { + return &[]; + } + let lo = self.ref_row[b as usize]; + let hi = self.ref_row[b as usize + 1]; + &self.ref_col[lo..hi] + } + + /// Whether the touch graph is present (profiles recorded before touch + /// recording, or built without a sink, lack it). + pub fn has_touch_graph(&self) -> bool { + !self.touch_row.is_empty() + } + + /// Block ids consulted while checking block `b` (sorted, deduped, no + /// self-edges). Empty when no touch graph was recorded. This is the + /// measured ingress set of `b` minus `b` itself: what a lazy checker + /// faulted in to check it. + pub fn touched_blocks(&self, b: u32) -> &[u32] { + if self.touch_row.is_empty() { + return &[]; + } + let lo = self.touch_row[b as usize]; + let hi = self.touch_row[b as usize + 1]; + &self.touch_col[lo..hi] + } + + /// Attach the block-level reference graph (per-block sorted, deduped, + /// self-edge-free referenced ids; one row per block). + pub fn set_ref_graph(&mut self, adj: &[Vec]) { + assert_eq!(adj.len(), self.blocks.len()); + self.ref_row = Vec::with_capacity(adj.len() + 1); + self.ref_row.push(0); + self.ref_col = Vec::with_capacity(adj.iter().map(Vec::len).sum()); + for row in adj { + self.ref_col.extend_from_slice(row); + self.ref_row.push(self.ref_col.len()); + } + } + /// Serialize to the `.ixprof` binary format. pub fn to_bytes(&self) -> Vec { let n = self.blocks.len(); let mut out = Vec::with_capacity( - 8 + 4 + 4 + n * 80 + 8 + (n + 1) * 8 + self.delta_col.len() * 4, + 8 + 4 + 4 + n * 96 + 8 + (n + 1) * 8 + self.delta_col.len() * 4, ); out.extend_from_slice(MAGIC); out.extend_from_slice(&VERSION.to_le_bytes()); @@ -258,18 +383,25 @@ impl BlockProfile { out.extend_from_slice(&b.serialized_size.to_le_bytes()); out.extend_from_slice(&b.const_count.to_le_bytes()); out.extend_from_slice(&b.subst.to_le_bytes()); + out.extend_from_slice(&b.subst_unique.to_le_bytes()); out.extend_from_slice(&b.whnf.to_le_bytes()); out.extend_from_slice(&b.def_eq.to_le_bytes()); out.extend_from_slice(&b.nat_arith.to_le_bytes()); out.extend_from_slice(&b.intern.to_le_bytes()); } - out.extend_from_slice(&(self.delta_col.len() as u64).to_le_bytes()); - // CSR row offsets (n+1 entries) as u64. - for &off in &self.delta_row { - out.extend_from_slice(&(off as u64).to_le_bytes()); - } - for &p in &self.delta_col { - out.extend_from_slice(&p.to_le_bytes()); + // CSR sections. The delta graph is always present; the reference and + // touch graphs are each framed by a one-byte presence flag so either + // can be absent without EOF inference. + write_csr(&mut out, &self.delta_row, &self.delta_col); + for (row, col) in + [(&self.ref_row, &self.ref_col), (&self.touch_row, &self.touch_col)] + { + if row.is_empty() { + out.push(0); + } else { + out.push(1); + write_csr(&mut out, row, col); + } } out } @@ -294,6 +426,7 @@ impl BlockProfile { let serialized_size = r.u32()?; let const_count = r.u32()?; let subst = r.u64()?; + let subst_unique = r.u64()?; let whnf = r.u64()?; let def_eq = r.u64()?; let nat_arith = r.u64()?; @@ -304,39 +437,32 @@ impl BlockProfile { serialized_size, const_count, subst, + subst_unique, whnf, def_eq, nat_arith, intern, }); } - let num_edges = r.u64()? as usize; - let mut delta_row = Vec::with_capacity(n + 1); - for _ in 0..n + 1 { - delta_row.push(r.u64()? as usize); - } - let mut delta_col = Vec::with_capacity(num_edges); - for _ in 0..num_edges { - delta_col.push(r.u32()?); - } - // Structural validation: monotone offsets bounded by edge count, in-range ids. - if delta_row.len() != n + 1 - || delta_row.first() != Some(&0) - || delta_row.last() != Some(&num_edges) - { - return Err(ProfileError::Corrupt); - } - for w in delta_row.windows(2) { - if w[0] > w[1] { - return Err(ProfileError::Corrupt); + let (delta_row, delta_col) = read_csr(&mut r, n)?; + let mut optional = [(Vec::new(), Vec::new()), (Vec::new(), Vec::new())]; + for slot in &mut optional { + match r.u8()? { + 0 => {}, + 1 => *slot = read_csr(&mut r, n)?, + _ => return Err(ProfileError::Corrupt), } } - for &p in &delta_col { - if p as usize >= n { - return Err(ProfileError::Corrupt); - } - } - Ok(BlockProfile { blocks, delta_row, delta_col }) + let [(ref_row, ref_col), (touch_row, touch_col)] = optional; + Ok(BlockProfile { + blocks, + delta_row, + delta_col, + ref_row, + ref_col, + touch_row, + touch_col, + }) } } @@ -383,6 +509,9 @@ impl<'a> Reader<'a> { self.pos = end; Ok(s) } + fn u8(&mut self) -> Result { + Ok(self.take(1)?[0]) + } fn u32(&mut self) -> Result { Ok(u32::from_le_bytes(self.take(4)?.try_into().unwrap())) } @@ -391,6 +520,42 @@ impl<'a> Reader<'a> { } } +/// Serialize one CSR section: edge count, `n+1` u64 row offsets, u32 columns. +fn write_csr(out: &mut Vec, row: &[usize], col: &[u32]) { + out.extend_from_slice(&(col.len() as u64).to_le_bytes()); + for &off in row { + out.extend_from_slice(&(off as u64).to_le_bytes()); + } + for &c in col { + out.extend_from_slice(&c.to_le_bytes()); + } +} + +/// Read and structurally validate one CSR section over `n` blocks: offsets +/// monotone from 0 to the edge count, column ids in range. +fn read_csr( + r: &mut Reader<'_>, + n: usize, +) -> Result<(Vec, Vec), ProfileError> { + let num_edges = r.u64()? as usize; + let mut row = Vec::with_capacity(n + 1); + for _ in 0..n + 1 { + row.push(r.u64()? as usize); + } + let mut col = Vec::with_capacity(num_edges); + for _ in 0..num_edges { + col.push(r.u32()?); + } + if row.first() != Some(&0) + || row.last() != Some(&num_edges) + || row.windows(2).any(|w| w[0] > w[1]) + || col.iter().any(|&x| x as usize >= n) + { + return Err(ProfileError::Corrupt); + } + Ok((row, col)) +} + /// Accumulates block-level statistics and delta edges (keyed by address), then /// freezes into a [`BlockProfile`] with stable, address-sorted block ids. /// @@ -411,6 +576,7 @@ struct Accum { const_count: u32, ops: OpCounts, producers: FxHashSet
, + touched: FxHashSet
, } impl ProfileBuilder { @@ -448,6 +614,17 @@ impl ProfileBuilder { self.blocks.entry(consumer).or_default().producers.insert(producer); } + /// Record that checking `consumer` consulted `target` (`try_get_const`), + /// whether its body was unfolded or only its type read. Self-edges are + /// ignored; both endpoints are ensured as blocks, like [`Self::delta_edge`]. + pub fn touch_edge(&mut self, consumer: Address, target: Address) { + if consumer == target { + return; + } + self.blocks.entry(target.clone()).or_default(); + self.blocks.entry(consumer).or_default().touched.insert(target); + } + /// Freeze into an immutable [`BlockProfile`]. Block ids are assigned by /// sorting addresses, so the result is deterministic regardless of insertion /// order. @@ -461,6 +638,10 @@ impl ProfileBuilder { let mut delta_row = Vec::with_capacity(addrs.len() + 1); let mut delta_col = Vec::new(); delta_row.push(0usize); + let mut touch_row = Vec::with_capacity(addrs.len() + 1); + let mut touch_col = Vec::new(); + touch_row.push(0usize); + let any_touches = self.blocks.values().any(|a| !a.touched.is_empty()); for addr in &addrs { let a = &self.blocks[addr]; @@ -470,6 +651,7 @@ impl ProfileBuilder { serialized_size: a.serialized_size, const_count: a.const_count, subst: a.ops.subst_nodes, + subst_unique: a.ops.subst_unique, whnf: a.ops.whnf_calls, def_eq: a.ops.def_eq_calls, nat_arith: a.ops.nat_arith, @@ -480,9 +662,28 @@ impl ProfileBuilder { prods.dedup(); delta_col.extend_from_slice(&prods); delta_row.push(delta_col.len()); + let mut touches: Vec = a.touched.iter().map(|t| id_of[t]).collect(); + touches.sort_unstable(); + touches.dedup(); + touch_col.extend_from_slice(&touches); + touch_row.push(touch_col.len()); + } + // A profile recorded without touch instrumentation has no touch graph + // at all, which readers distinguish from "recorded, all rows empty". + if !any_touches { + touch_row = Vec::new(); + touch_col = Vec::new(); } - BlockProfile { blocks, delta_row, delta_col } + BlockProfile { + blocks, + delta_row, + delta_col, + ref_row: Vec::new(), + ref_col: Vec::new(), + touch_row, + touch_col, + } } } @@ -508,6 +709,10 @@ pub struct ConstRecord { pub fuel: u64, /// Constant addresses whose bodies were delta-unfolded during the check. pub producers: FxHashSet
, + /// Constant addresses CONSULTED during the check (`try_get_const`) — + /// a superset of `producers` that also covers type-only reads. The + /// measured ingress set of a lazy checker. + pub touched: FxHashSet
, /// Richer cost features (substitution-node visits, whnf/def-eq calls), /// recorded on every native profiling run; compiled out (all zero) on the /// zkvm target. @@ -520,17 +725,20 @@ impl ProfileSink { } /// Accumulate one constant's record (additive in fuel + op counts, set-union - /// in producers) so repeated flushes for the same constant combine correctly. + /// in producers/touched) so repeated flushes for the same constant combine + /// correctly. pub fn record( &mut self, consumer: Address, fuel: u64, producers: impl IntoIterator, + touched: impl IntoIterator, ops: OpCounts, ) { let rec = self.records.entry(consumer).or_default(); rec.fuel = rec.fuel.saturating_add(fuel); rec.producers.extend(producers); + rec.touched.extend(touched); rec.ops.add(&ops); } @@ -540,6 +748,7 @@ impl ProfileSink { let e = self.records.entry(addr).or_default(); e.fuel = e.fuel.saturating_add(rec.fuel); e.producers.extend(rec.producers); + e.touched.extend(rec.touched); e.ops.add(&rec.ops); } } @@ -568,6 +777,11 @@ mod tests { b.delta_edge(addr(1), addr(3)); b.delta_edge(addr(3), addr(2)); b.delta_edge(addr(2), addr(2)); + // a consulted c; b consulted a and c; self-edge ignored. + b.touch_edge(addr(1), addr(3)); + b.touch_edge(addr(2), addr(1)); + b.touch_edge(addr(2), addr(3)); + b.touch_edge(addr(3), addr(3)); b.finish() } @@ -606,12 +820,36 @@ mod tests { assert_eq!(got, vec![0, 2]); } + #[test] + fn touch_graph_sorted_self_edge_dropped_and_absent_when_unrecorded() { + let p = sample(); + assert!(p.has_touch_graph()); + // block 0 (addr 1) consulted block 2; block 1 consulted blocks 0 and 2. + assert_eq!(p.touched_blocks(0), &[2]); + assert_eq!(p.touched_blocks(1), &[0, 2]); + // block 2 (addr 3): self-edge dropped → no touches. + assert_eq!(p.touched_blocks(2), &[]); + // A builder fed no touch edges yields no touch graph at all. + let mut b = ProfileBuilder::new(); + b.block(addr(1), 1, 1, 1, ops(0)); + let q = b.finish(); + assert!(!q.has_touch_graph()); + assert_eq!(q.touched_blocks(0), &[]); + } + #[test] fn roundtrip_serialization() { let p = sample(); let bytes = p.to_bytes(); let q = BlockProfile::from_bytes(&bytes).unwrap(); assert_eq!(p, q); + // Absent optional sections roundtrip as absent, not as empty-present. + let mut b = ProfileBuilder::new(); + b.block(addr(1), 1, 1, 1, ops(0)); + let bare = b.finish(); + let r = BlockProfile::from_bytes(&bare.to_bytes()).unwrap(); + assert_eq!(bare, r); + assert!(!r.has_touch_graph() && !r.has_ref_graph()); } #[test] @@ -634,12 +872,16 @@ mod tests { // via separate builders merged conceptually; result must be identical. let mut b = ProfileBuilder::new(); b.delta_edge(addr(3), addr(2)); + b.touch_edge(addr(2), addr(3)); b.block(addr(3), 300, 30, 1, ops(150)); b.delta_edge(addr(1), addr(3)); + b.touch_edge(addr(3), addr(3)); b.block(addr(2), 200, 20, 3, ops(100)); b.delta_edge(addr(1), addr(2)); + b.touch_edge(addr(2), addr(1)); b.block(addr(1), 100, 10, 1, ops(50)); b.delta_edge(addr(2), addr(2)); + b.touch_edge(addr(1), addr(3)); assert_eq!(b.finish(), sample()); } } diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index abdf4cc94..f2af703fd 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -1648,6 +1648,99 @@ pub fn shard_esp_cap( )) } +/// Like [`shard_esp_cap`] but sized to a per-shard **Aiur host-RAM** budget +/// (GiB) via the calibrated Aiur cost model (see [`partition_for_aiur_ram`]). +/// The manifest format is backend-neutral; only the packing objective and the +/// report change. Alongside the manifest a `.costs.csv` sidecar records +/// the packer's per-shard accounting and predictions, for +/// measured-vs-predicted comparison, refits, and heaviest-first prove +/// scheduling. +pub fn shard_esp_aiur( + esp_path: &str, + ram_budget_gib: f64, + balance: f64, + parallelism: usize, + out_path: Option<&str>, +) -> Result { + let bytes = + std::fs::read(esp_path).map_err(|e| format!("read {esp_path}: {e}"))?; + let profile = BlockProfile::from_bytes(&bytes) + .map_err(|e| format!("parse {esp_path}: {e}"))?; + if !profile.has_touch_graph() && !profile.has_ref_graph() { + return Err(format!( + "{esp_path} has neither a touch graph nor a reference graph — Aiur \ + packing needs one for its faulted-set byte accounting; regenerate \ + with the current `ix profile`" + )); + } + let plan = partition_for_aiur_ram(&profile, ram_budget_gib, balance); + let mut manifest = + ShardManifest::build(&profile, &plan.shard_of, plan.num_shards) + .with_tree(plan.tree); + for shard in &mut manifest.shards { + shard.assumption_root = + ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); + } + if let Some(op) = out_path { + std::fs::write(op, manifest.to_bytes()) + .map_err(|e| format!("write {op}: {e}"))?; + } + let prove_secs: Vec = plan + .shard_costs + .iter() + .map(|c| aiur_prove_secs(c.union_bytes, c.subst)) + .collect(); + if let Some(op) = out_path { + let mut csv = String::from( + "shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,\ + pred_ram_gib,pred_prove_s\n", + ); + for (i, c) in plan.shard_costs.iter().enumerate() { + csv.push_str(&format!( + "{},{},{},{},{},{},{},{},{:.2},{:.2}\n", + i, + c.union_bytes, + c.hb, + c.subst, + c.subst_unique, + c.whnf, + c.def_eq, + c.nat_arith, + aiur_ram_gib(c.union_bytes, c.hb), + prove_secs[i], + )); + } + let cp = format!("{op}.costs.csv"); + std::fs::write(&cp, csv).map_err(|e| format!("write {cp}: {e}"))?; + } + let seq_secs: f64 = prove_secs.iter().sum(); + let max_secs = prove_secs.iter().fold(0.0f64, |a, &s| a.max(s)); + let p = parallelism.max(1); + #[allow(clippy::cast_precision_loss)] + let wall_secs = (seq_secs / p as f64).max(max_secs); + let note = if plan.infeasible_atomic_floor { + "\n [INFEASIBLE: a single atomic block exceeds the RAM cap — split it upstream, raise the budget, or use a bigger box]" + } else { + "" + }; + Ok(format!( + "blocks={} delta_edges={} aiur ram_budget={:.0} GiB (cap {:.1} at {:.0}% usable) → {} shards (packed to cap)\n{}\nprove est ~{} wall at parallelism={} (sequential ~{})\nmax_shard_ram={:.1} GiB largest_block_ram={:.1} GiB{}", + profile.num_blocks(), + profile.num_edges(), + ram_budget_gib, + plan.ram_cap_gib, + AIUR_RAM_USABLE_FRAC * 100.0, + plan.num_shards, + manifest.summary(), + fmt_duration(wall_secs), + p, + fmt_duration(seq_secs), + plan.max_shard_ram_gib, + plan.largest_block_ram_gib, + note, + )) +} + /// Calibrated Zisk guest-COST model — the **single source of truth** for /// predicting a block's in-circuit cost contribution, in **ziskemu cost /// units** (`ziskemu -X` TOTAL: MAIN + OPCODES + MEMORY + PRECOMPILES + @@ -1762,6 +1855,89 @@ pub fn shard_prove_secs(steps: u64) -> f64 { PROVE_SETUP_SECS + PROVE_SECS_PER_BCOST * (steps as f64 / 1e9) } +/// `x·log₂(x+2)` — the feature form of the Aiur cost model. Aiur's prover work +/// is a sum of `width·height·log₂(height)` FFTs over its circuits, and each +/// dominant circuit family's height tracks one kernel counter, so a counter's +/// cost contribution is super-linear with exactly this shape. The `+2` keeps +/// the log positive at zero. +#[allow(clippy::cast_precision_loss)] // counters are far below 2^53 +fn nlogn(x: u64) -> f64 { + let x = x as f64; + x * (x + 2.0).log2() +} + +/// Calibrated Aiur cost model — predicts a **run's** (one Aiur prove: a whole +/// closure or one shard) prove time and peak host RAM directly from the kernel +/// profile counters, no Aiur execution needed. Features are run-level +/// aggregates: `bytes` is every serialized byte the run's checks fault in +/// (owned blocks plus the measured touched set — under the lazy kernel only +/// faulted bytes cost ingress trace rows), `hb`/`subst` are the run's summed +/// reduction counters. Fit against measured `aiur-check-prove` bench-suite +/// runs (bencher.dev `ix` project) of the pre-addr-first eager-ingress +/// kernel; coefficients and fit quality live in the calibrating commit's +/// message. Known limit: constants whose Aiur cost is dominated by big-Nat +/// limb gadgets have no native-counter signal and under-predict; +/// [`AIUR_RAM_USABLE_FRAC`] carries that risk. +pub const AIUR_PROVE_BASE_SECS: f64 = 1.43; +pub const AIUR_PROVE_SECS_PER_NLOGN_INGRESS_BYTE: f64 = 2.38e-7; +pub const AIUR_PROVE_SECS_PER_NLOGN_SUBST: f64 = 9.06e-7; +pub const AIUR_RAM_BASE_GIB: f64 = 3.67; +pub const AIUR_RAM_GIB_PER_NLOGN_INGRESS_BYTE: f64 = 1.18e-6; +pub const AIUR_RAM_GIB_PER_NLOGN_HEARTBEAT: f64 = 1.57e-5; +/// Usable fraction of an Aiur host-RAM budget. Lower than the Zisk +/// [`RAM_USABLE_FRAC`]: it also absorbs the model's blind spot on +/// limb-arithmetic-heavy blocks, not just OS overhead and variance. +pub const AIUR_RAM_USABLE_FRAC: f64 = 0.7; + +/// Predicted Aiur prove time (seconds) for one run faulting in `bytes` and +/// performing `subst` substitution-node visits. +pub fn aiur_prove_secs(bytes: u64, subst: u64) -> f64 { + AIUR_PROVE_BASE_SECS + + AIUR_PROVE_SECS_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) + + AIUR_PROVE_SECS_PER_NLOGN_SUBST * nlogn(subst) +} + +/// Predicted Aiur peak host RAM (GiB) for one run faulting in `bytes` at `hb` +/// heartbeats of reduction. +pub fn aiur_ram_gib(bytes: u64, hb: u64) -> f64 { + AIUR_RAM_BASE_GIB + + AIUR_RAM_GIB_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) + + AIUR_RAM_GIB_PER_NLOGN_HEARTBEAT * nlogn(hb) +} + +/// A block's marginal predicted Aiur prove time (seconds), `nlogn` taken at +/// block granularity and the per-run base omitted. Slightly under-counts a +/// block's share inside a large run (whose `log` factor is bigger), which is +/// fine for its purpose: ranking blocks in the `ix profile` leaderboards. +pub fn aiur_block_prove_secs(b: &BlockEntry) -> f64 { + AIUR_PROVE_SECS_PER_NLOGN_INGRESS_BYTE * nlogn(u64::from(b.serialized_size)) + + AIUR_PROVE_SECS_PER_NLOGN_SUBST * nlogn(b.subst) +} + +/// Calibrated Aiur **execute** (witness-generation, no prove) cost model — +/// same feature form and calibration pipeline as the prove model above, fit +/// against the `aiur-check-execute` bench suite. Execute RAM is bytes-only: +/// the retained query record is dominated by ingress/hashing rows, and no +/// second feature survives a non-negative fit. +pub const AIUR_EXEC_BASE_SECS: f64 = 0.146; +pub const AIUR_EXEC_SECS_PER_NLOGN_INGRESS_BYTE: f64 = 8.54e-8; +pub const AIUR_EXEC_SECS_PER_NLOGN_SUBST: f64 = 6.77e-8; +pub const AIUR_EXEC_RAM_BASE_GIB: f64 = 4.72; +pub const AIUR_EXEC_RAM_GIB_PER_NLOGN_INGRESS_BYTE: f64 = 8.50e-8; + +/// Predicted Aiur execute time (seconds) for one run. +pub fn aiur_exec_secs(bytes: u64, subst: u64) -> f64 { + AIUR_EXEC_BASE_SECS + + AIUR_EXEC_SECS_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) + + AIUR_EXEC_SECS_PER_NLOGN_SUBST * nlogn(subst) +} + +/// Predicted Aiur execute peak host RAM (GiB) for one run. +pub fn aiur_exec_ram_gib(bytes: u64) -> f64 { + AIUR_EXEC_RAM_BASE_GIB + + AIUR_EXEC_RAM_GIB_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) +} + /// Whole-workload prove-time estimate over a partition's per-shard step counts. pub struct ProveEstimate { /// Σ predicted guest STEPS over all shards (incl. per-shard floor + ingress). @@ -1934,31 +2110,12 @@ pub fn partition_for_cycle_cap( }; } - // 1. Cut-coherent block order. A fine min-cut pre-partition's bisection tree, - // read in DFS order, lays tightly-coupled blocks contiguously so the packer - // keeps dependency overlap within a shard. Sized to ~PACK_PIECES_PER_CAP - // pieces per cap (bounded by the block count); when everything fits one cap - // this collapses to a trivial order. + // 1. Cut-coherent block order, sized to ~PACK_PIECES_PER_CAP pieces per cap. let total: u128 = profile.blocks().iter().map(|b| u128::from(block_step_cost(b))).sum(); let pieces = ((total.saturating_mul(PACK_PIECES_PER_CAP)) / u128::from(step_cap)) as usize; - let n_fine = pieces.clamp(1, nblocks); - let order: Vec = if n_fine < 2 { - (0..nblocks as u32).collect() - } else { - let h = Hypergraph::from_profile(profile); - let (fine_of, fine_tree) = h.partition_with_tree(n_fine, epsilon); - let mut leaf_order = Vec::with_capacity(n_fine); - dfs_leaf_order(&fine_tree, &mut leaf_order); - let mut rank = vec![0u32; n_fine]; - for (r, &sid) in leaf_order.iter().enumerate() { - rank[sid as usize] = r as u32; - } - let mut order: Vec = (0..nblocks as u32).collect(); - order.sort_by_key(|&b| (rank[fine_of[b as usize] as usize], b)); - order - }; + let order = cut_coherent_order(profile, pieces, epsilon); // 2. Greedy next-fit packing to the cap, with live cross-ingress accounting. // A shard accumulates members until adding the next block would push its @@ -2055,6 +2212,316 @@ pub fn partition_for_cycle_cap( } } +/// One shard's Aiur cost aggregates as the packer accounted them: the +/// faulted-set ingress bytes plus the owned blocks' checking counters. +#[derive(Clone, Copy, Debug, Default)] +pub struct AiurShardCost { + /// Serialized bytes of the shard's faulted set (owned ∪ every block the + /// owned checks consulted per the touch graph; full reference closure + /// when no touch graph was recorded) — what the shard's CheckEnv run + /// ingresses and hashes under the lazy kernel. + pub union_bytes: u64, + /// Σ heartbeats over owned blocks only (frontier constants are assumptions, + /// never re-checked). + pub hb: u64, + /// Σ substitution-node visits over owned blocks only. + pub subst: u64, + /// Σ memo-unique substitution work items over owned blocks only — the + /// post-memoization volume a memoizing executor pays; persisted per shard + /// so the models can eventually be refit against it. + pub subst_unique: u64, + /// Σ `whnf` entries over owned blocks only. + pub whnf: u64, + /// Σ definitional-equality checks over owned blocks only. + pub def_eq: u64, + /// Σ big-Nat limb-work units over owned blocks only — the klimbs + /// circuit family's only recorded signal; persisted per shard so the + /// RAM model's content residual can eventually be fit against it. + pub nat_arith: u64, +} + +/// A partition sized to a per-shard Aiur host-RAM budget. The Aiur analog of +/// [`BudgetPlan`], reported in the Aiur model's native unit (GiB) rather than +/// guest steps. +pub struct AiurBudgetPlan { + /// Chosen shard count. + pub num_shards: usize, + /// Shard assignment per block id. + pub shard_of: Vec, + /// The bisection tree for the chosen partition, for tree-aligned aggregation. + pub tree: AggNode, + /// Per-shard predicted-RAM cap actually enforced: + /// `budget × AIUR_RAM_USABLE_FRAC`. + pub ram_cap_gib: f64, + /// Per-shard cost aggregates, indexed by shard id. + pub shard_costs: Vec, + /// Heaviest shard's full predicted RAM — the tightest number to compare + /// against the cap. + pub max_shard_ram_gib: f64, + /// Largest single block's predicted RAM with its full faulted-set ingress — + /// the hard floor no shard count can beat: every shard containing the + /// block faults in at least that set. + pub largest_block_ram_gib: f64, + /// True when one block alone (faulted set included) exceeds the cap. + pub infeasible_atomic_floor: bool, +} + +/// Size a partition to a per-shard Aiur host-RAM budget by bin-packing to the +/// cap — the Aiur counterpart of [`partition_for_cycle_cap`], with the same +/// cut-coherent-order + greedy next-fit structure but **faulted-set byte +/// accounting**. +/// +/// Under the addr-first kernel a shard's witness ships its owned blocks' full +/// dependency closure, but only bytes the checks actually fault in cost +/// ingress trace rows (an unfaulted constant contributes zero queries), so +/// the packer charges the *faulted* set. With a **touch graph** (recorded by +/// a profiling run) that set is a measurement: each owned block contributes +/// itself plus every block its check consulted — type reads included, and +/// transitively complete because consults during reduction are recorded +/// against the owned consumer. Without a touch graph the accounting falls +/// back to the full reference closure, an over-approximation that +/// over-shards but never under-budgets. +/// +/// Checking counters (hb/subst/…) stay owned-blocks-only. Grouping blocks +/// with overlapping faulted sets is the packing objective that matters: a +/// shared dependency's bytes are paid once per shard that faults it. +/// +/// Requires the profile's reference graph when no touch graph is present; +/// the caller rejects profiles with neither. +pub fn partition_for_aiur_ram( + profile: &BlockProfile, + ram_budget_gib: f64, + epsilon: f64, +) -> AiurBudgetPlan { + let ram_cap_gib = ram_budget_gib * AIUR_RAM_USABLE_FRAC; + let nblocks = profile.num_blocks(); + let size = |b: u32| u64::from(profile.block(b).serialized_size); + let measured = profile.has_touch_graph(); + + if nblocks == 0 { + return AiurBudgetPlan { + num_shards: 1, + shard_of: Vec::new(), + tree: AggNode::Leaf(0), + ram_cap_gib, + shard_costs: Vec::new(), + max_shard_ram_gib: AIUR_RAM_BASE_GIB, + largest_block_ram_gib: 0.0, + infeasible_atomic_floor: false, + }; + } + + // Per-block faulted-set bytes (the block's lone-shard ingress) — the RAM + // floor per block and the infeasibility test. Measured: the touch row is + // already the transitive consult set. Fallback: full reference-closure + // BFS, parallel with per-worker epoch-marked state. + let closure_bytes: Vec = if measured { + (0..nblocks as u32) + .map(|b| { + profile + .touched_blocks(b) + .iter() + .map(|&t| size(t)) + .fold(size(b), u64::saturating_add) + }) + .collect() + } else { + use rayon::prelude::*; + (0..nblocks as u32) + .into_par_iter() + .map_init( + || (vec![0u32; nblocks], 0u32, Vec::::new()), + |(visited, epoch, stack), b| { + *epoch += 1; + let mut bytes = 0u64; + stack.clear(); + stack.push(b); + visited[b as usize] = *epoch; + while let Some(x) = stack.pop() { + bytes = bytes.saturating_add(size(x)); + for &r in profile.refs(x) { + if visited[r as usize] != *epoch { + visited[r as usize] = *epoch; + stack.push(r); + } + } + } + bytes + }, + ) + .collect() + }; + let lone_block_ram = |b: u32| { + aiur_ram_gib(closure_bytes[b as usize], profile.block(b).heartbeats) + }; + let largest_block_ram_gib = + (0..nblocks as u32).map(lone_block_ram).fold(0.0, f64::max); + + // 1. Cut-coherent block order. Piece sizing uses the whole-env totals as a + // granularity proxy (faulted-set bytes are not additive across pieces); + // the order's job is only to keep overlapping blocks adjacent, which + // the min-cut on shared-dependency nets already does. + let total_bytes: u64 = profile + .blocks() + .iter() + .fold(0u64, |a, b| a.saturating_add(u64::from(b.serialized_size))); + let total_hb: u64 = + profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.heartbeats)); + let total_ram = aiur_ram_gib(total_bytes, total_hb) - AIUR_RAM_BASE_GIB; + let headroom = (ram_cap_gib - AIUR_RAM_BASE_GIB).max(f64::MIN_POSITIVE); + #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] + let pieces = (total_ram / headroom * PACK_PIECES_PER_CAP as f64) as usize; + let order = cut_coherent_order(profile, pieces, epsilon); + + // 2. Greedy next-fit packing to the RAM cap with live faulted-union + // accounting. `charged_mark[x] == shard_epoch` ⇔ x's bytes are already + // in the current shard's union; closing a shard bumps the epoch, which + // invalidates every mark at once (a rejected tentative walk leaves no + // residue — the candidate re-walks fresh in the next shard). + let mut shard_of = vec![0u32; nblocks]; + let mut charged_mark = vec![0u32; nblocks]; + let mut walk_mark = vec![0u32; nblocks]; + let mut shard_epoch = 1u32; + let mut stack: Vec = Vec::new(); + let mut cur_cost = AiurShardCost::default(); + let mut shard_costs: Vec = Vec::new(); + let mut cur = 0u32; + let mut owned_in_cur = 0usize; + let mut infeasible = false; + let predicted = |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.hb); + + // Byte delta of adding `b`'s faulted set to the current shard's union. + let union_delta = |b: u32, + shard_epoch: u32, + stack: &mut Vec, + charged_mark: &mut [u32], + walk_mark: &mut [u32]| + -> u64 { + let mut bytes = 0u64; + let charge = |x: u32, charged_mark: &mut [u32], bytes: &mut u64| { + if charged_mark[x as usize] != shard_epoch { + charged_mark[x as usize] = shard_epoch; + *bytes = bytes.saturating_add(size(x)); + } + }; + if measured { + charge(b, charged_mark, &mut bytes); + for &t in profile.touched_blocks(b) { + charge(t, charged_mark, &mut bytes); + } + } else { + // Reference-closure BFS, deduped per shard: a subtree expanded once + // this epoch is never re-walked for a later member. + if walk_mark[b as usize] != shard_epoch { + stack.clear(); + stack.push(b); + walk_mark[b as usize] = shard_epoch; + while let Some(x) = stack.pop() { + charge(x, charged_mark, &mut bytes); + for &r in profile.refs(x) { + if walk_mark[r as usize] != shard_epoch { + walk_mark[r as usize] = shard_epoch; + stack.push(r); + } + } + } + } + } + bytes + }; + + for &b in &order { + let e = profile.block(b); + let delta = union_delta( + b, + shard_epoch, + &mut stack, + &mut charged_mark, + &mut walk_mark, + ); + let tentative = AiurShardCost { + union_bytes: cur_cost.union_bytes.saturating_add(delta), + hb: cur_cost.hb.saturating_add(e.heartbeats), + ..cur_cost + }; + + if owned_in_cur > 0 && predicted(&tentative) > ram_cap_gib { + // Close the shard, open a fresh union, re-walk b's faulted set. + shard_costs.push(cur_cost); + cur += 1; + shard_epoch += 1; + owned_in_cur = 0; + cur_cost = AiurShardCost::default(); + cur_cost.union_bytes = union_delta( + b, + shard_epoch, + &mut stack, + &mut charged_mark, + &mut walk_mark, + ); + } else { + cur_cost.union_bytes = tentative.union_bytes; + } + cur_cost.hb = cur_cost.hb.saturating_add(e.heartbeats); + cur_cost.subst = cur_cost.subst.saturating_add(e.subst); + cur_cost.subst_unique = + cur_cost.subst_unique.saturating_add(e.subst_unique); + cur_cost.whnf = cur_cost.whnf.saturating_add(e.whnf); + cur_cost.def_eq = cur_cost.def_eq.saturating_add(e.def_eq); + cur_cost.nat_arith = cur_cost.nat_arith.saturating_add(e.nat_arith); + owned_in_cur += 1; + shard_of[b as usize] = cur; + if owned_in_cur == 1 && predicted(&cur_cost) > ram_cap_gib { + infeasible = true; + } + } + shard_costs.push(cur_cost); + let max_shard_ram_gib = shard_costs.iter().map(predicted).fold(0.0, f64::max); + + let num_shards = (cur + 1) as usize; + let tree = balanced_agg_tree(0, num_shards as u32); + + AiurBudgetPlan { + num_shards, + shard_of, + tree, + ram_cap_gib, + shard_costs, + max_shard_ram_gib, + largest_block_ram_gib, + infeasible_atomic_floor: infeasible, + } +} + +/// A cut-coherent block order for greedy cap-packing: a fine min-cut +/// pre-partition's bisection tree, read in DFS order, lays tightly-coupled +/// blocks contiguously so a next-fit packer keeps dependency overlap within a +/// shard. `pieces` is the requested fine-partition size (~[`PACK_PIECES_PER_CAP`] +/// per cap, in the caller's cost unit), bounded by the block count; when +/// everything fits one cap this collapses to the trivial order. +fn cut_coherent_order( + profile: &BlockProfile, + pieces: usize, + epsilon: f64, +) -> Vec { + let nblocks = profile.num_blocks(); + let n_fine = pieces.clamp(1, nblocks); + if n_fine < 2 { + return (0..nblocks as u32).collect(); + } + let h = Hypergraph::from_profile(profile); + let (fine_of, fine_tree) = h.partition_with_tree(n_fine, epsilon); + let mut leaf_order = Vec::with_capacity(n_fine); + dfs_leaf_order(&fine_tree, &mut leaf_order); + let mut rank = vec![0u32; n_fine]; + for (r, &sid) in leaf_order.iter().enumerate() { + rank[sid as usize] = r as u32; + } + let mut order: Vec = (0..nblocks as u32).collect(); + order.sort_by_key(|&b| (rank[fine_of[b as usize] as usize], b)); + order +} + /// Collect the leaf shard ids of an [`AggNode`] in left-to-right DFS order. fn dfs_leaf_order(node: &AggNode, out: &mut Vec) { match node { @@ -2313,6 +2780,157 @@ mod tests { assert!(plan.infeasible_atomic_floor, "oversized atomic block must flag"); } + #[test] + fn aiur_model_monotone() { + // The packer's greedy cap test is only sound if the model never decreases + // when a shard grows in either aggregate. + let base = aiur_ram_gib(1_000_000, 10_000); + assert!(aiur_ram_gib(2_000_000, 10_000) > base); + assert!(aiur_ram_gib(1_000_000, 20_000) > base); + let p = aiur_prove_secs(1_000_000, 100_000); + assert!(aiur_prove_secs(2_000_000, 100_000) > p); + assert!(aiur_prove_secs(1_000_000, 200_000) > p); + } + + /// Attach a reference graph given per-block (sorted, deduped) ref lists. + fn with_refs(mut p: BlockProfile, adj: &[Vec]) -> BlockProfile { + p.set_ref_graph(adj); + p + } + + #[test] + fn aiur_ram_cap_respected() { + // 40-block chain (each references the next), uniform weights: the packer + // must split into multiple shards each under the (usable-fraction) cap, + // where a shard's bytes are its closure UNION — for a chain, everything + // downstream of its first member. + let mut b = ProfileBuilder::new(); + for i in 1..=40u8 { + b.block(addr(i), 10_000, 20_000, 1, ops(100_000)); + } + for i in 1..40u8 { + b.delta_edge(addr(i), addr(i + 1)); + } + let adj: Vec> = + (0..40u32).map(|i| if i < 39 { vec![i + 1] } else { vec![] }).collect(); + let p = with_refs(b.finish(), &adj); + let budget = 64.0; + let plan = partition_for_aiur_ram(&p, budget, 0.05); + assert!(plan.num_shards > 1, "must shard: whole env exceeds the budget"); + assert!( + plan.max_shard_ram_gib <= plan.ram_cap_gib, + "heaviest shard {} exceeds cap {}", + plan.max_shard_ram_gib, + plan.ram_cap_gib, + ); + // Every block is assigned, ids contiguous. + assert_eq!(plan.shard_of.len(), 40); + let max_id = plan.shard_of.iter().copied().max().unwrap() as usize; + assert_eq!(max_id + 1, plan.num_shards); + } + + #[test] + fn aiur_union_counts_shared_dep_once() { + // Blocks 0 and 1 both reference deep dep 2 (which references 3). Packed + // into one shard, the union must charge {0,1,2,3} once — NOT + // closure(0)+closure(1). + let mut b = ProfileBuilder::new(); + for i in 1..=4u8 { + b.block(addr(i), 10, 1000, 1, ops(0)); + } + let p = with_refs(b.finish(), &[vec![2], vec![2], vec![3], vec![]]); + let plan = partition_for_aiur_ram(&p, 1000.0, 0.05); + assert_eq!(plan.num_shards, 1); + assert_eq!(plan.shard_costs[0].union_bytes, 4000); + assert_eq!(plan.shard_costs[0].hb, 40); + } + + #[test] + fn aiur_measured_charges_touched_not_closure() { + // refs 0→1, 1→{2,3}; the recording run's check of block 0 consulted only + // 1 (touch edge). Measured accounting charges block 0's faulted set + // {0,1} = 2000 — the reference closure {0,1,2,3} = 4000 is what a + // touch-free profile falls back to. + let build = |touch: bool| { + let mut b = ProfileBuilder::new(); + for i in 1..=4u8 { + b.block(addr(i), 10, 1000, 1, ops(0)); + } + if touch { + b.touch_edge(addr(1), addr(2)); + } + with_refs(b.finish(), &[vec![1], vec![2, 3], vec![], vec![]]) + }; + let fallback = partition_for_aiur_ram(&build(false), 1000.0, 0.05); + assert!( + (fallback.largest_block_ram_gib - aiur_ram_gib(4000, 10)).abs() < 1e-9 + ); + let measured = partition_for_aiur_ram(&build(true), 1000.0, 0.05); + assert!( + (measured.largest_block_ram_gib - aiur_ram_gib(2000, 10)).abs() < 1e-9 + ); + } + + #[test] + fn aiur_ingress_expands_refs_when_member_becomes_owned() { + // Block 0 refs 1; block 1 refs 2. Packing 0 first pulls 1 (and, via the + // closure walk, 2) into the union; packing 1 as OWNED afterwards must + // not double-charge any of them. + let mut b = ProfileBuilder::new(); + for i in 1..=3u8 { + b.block(addr(i), 10, 1000, 1, ops(0)); + } + let p = with_refs(b.finish(), &[vec![1], vec![2], vec![]]); + let plan = partition_for_aiur_ram(&p, 1000.0, 0.05); + assert_eq!(plan.num_shards, 1); + assert_eq!(plan.shard_costs[0].union_bytes, 3000); + } + + #[test] + fn aiur_floor_is_closure_bytes() { + // A cheap block referencing a huge dependency: its lone-shard RAM floor + // must include the dependency's bytes even though its own are tiny. + let mut b = ProfileBuilder::new(); + b.block(addr(1), 10, 100, 1, ops(0)); + b.block(addr(2), 10, 3_000_000, 1, ops(0)); + let p = with_refs(b.finish(), &[vec![1], vec![]]); + let plan = partition_for_aiur_ram(&p, 1000.0, 0.05); + let floor = aiur_ram_gib(3_000_100, 10); + assert!( + (plan.largest_block_ram_gib - floor).abs() < 1e-9, + "floor {} != closure-based {}", + plan.largest_block_ram_gib, + floor, + ); + } + + #[test] + fn aiur_flags_infeasible_atomic_block() { + // One block so hot its lone predicted RAM exceeds the cap: emitted alone, + // flagged infeasible. + let mut b = ProfileBuilder::new(); + b.block(addr(1), u64::MAX / 2, 1000, 1, ops(1000)); + b.block(addr(2), 10, 1000, 1, ops(0)); + let p = with_refs(b.finish(), &[vec![], vec![]]); + let plan = partition_for_aiur_ram(&p, 8.0, 0.05); + assert!(plan.infeasible_atomic_floor, "oversized atomic block must flag"); + } + + #[test] + fn ref_graph_roundtrips_through_ixprof() { + let mut b = ProfileBuilder::new(); + for i in 1..=3u8 { + b.block(addr(i), 1, 10, 1, ops(2)); + } + let p = with_refs(b.finish(), &[vec![1, 2], vec![2], vec![]]); + let q = BlockProfile::from_bytes(&p.to_bytes()).unwrap(); + assert!(q.has_ref_graph()); + assert_eq!(q.refs(0), &[1, 2]); + assert_eq!(q.refs(1), &[2]); + assert_eq!(q.refs(2), &[] as &[u32]); + assert_eq!(p, q); + } + #[test] fn shard_esp_file_roundtrip() { // Exercise the CLI's shard path: write a .ixprof, run shard_esp, read back diff --git a/crates/kernel/src/subst.rs b/crates/kernel/src/subst.rs index 9779c76ba..13a0423bc 100644 --- a/crates/kernel/src/subst.rs +++ b/crates/kernel/src/subst.rs @@ -828,6 +828,15 @@ pub fn instantiate_rev( if fvars.is_empty() || body.lbr() == 0 { return body.clone(); } + // Profiler: the substitution-context half of the unique-work key — a + // fold of the fvar identities, set once per top-level call (the + // recursion below never re-enters subst, so the slot stays valid). + #[cfg(not(target_os = "zkvm"))] + crate::profile::set_subst_ctx( + fvars.iter().fold(0xcbf2_9ce4_8422_2325_u64, |h, f| { + (h ^ f.hash_key()).wrapping_mul(0x0000_0100_0000_01b3) + }), + ); // Borrow the dedicated `subst_scratch` (same allocation reuse trick as // `subst`/`simul_subst`). `instantiate_rev_cached` does not call back // into subst/simul_subst/lift, so the scratch is safe to share across @@ -847,9 +856,12 @@ fn instantiate_rev_cached( cache: &mut FxHashMap<(Addr, u64), KExpr>, ) -> KExpr { // Profiler: count every substitution-node visit — the work-volume feature - // that `heartbeats` (step count) misses. Records out of circuit; the bump - // compiles out on the zkvm target. + // that `heartbeats` (step count) misses — and its memo-deduplicated + // counterpart keyed on (expr, depth, substitution context). Records out + // of circuit; both bumps compile out on the zkvm target. crate::profile::bump_subst_nodes(); + #[cfg(not(target_os = "zkvm"))] + crate::profile::bump_subst_unique(body.hash_key(), depth); // No loose bvars at or below `depth` means nothing to instantiate at // this subtree. if body.lbr() <= depth { diff --git a/crates/kernel/src/tc.rs b/crates/kernel/src/tc.rs index 252798cc4..4f12b7048 100644 --- a/crates/kernel/src/tc.rs +++ b/crates/kernel/src/tc.rs @@ -172,6 +172,11 @@ pub struct TypeChecker<'a, M: KernelMode> { /// Addresses of constants whose bodies were delta-unfolded during the current /// constant's check. Drained per constant by `record_current_fuel_used`. pub(crate) delta_targets: FxHashSet
, + /// Every constant CONSULTED while checking the current one, whether its + /// body was unfolded or only its type read — the measured ingress set of + /// a lazy checker. Drained per constant by `record_current_fuel_used` + /// into the profile sink, which persists it as the `.ixprof` touch graph. + pub(crate) touched: FxHashSet
, /// Gated miss sampler for fuel-exhaustion diagnostics. Populated only when /// `IX_HOT_MISSES=1`, keyed by a compact phase/head/lbr shape. hot_misses: FxHashMap, @@ -222,6 +227,7 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> { debug_label: None, cur_const: None, delta_targets: FxHashSet::default(), + touched: FxHashSet::default(), hot_misses: FxHashMap::default(), ctx_addr_cache: FxHashMap::default(), lctx: super::lctx::LocalContext::new(), @@ -252,6 +258,9 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> { &mut self, id: &KId, ) -> Result>, TcError> { + if self.env.profile_sink.is_some() { + self.touched.insert(id.addr.clone()); + } if let Some(c) = self.env.get(id) { return Ok(Some(c)); } @@ -914,13 +923,19 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> { // delta-unfold edges. `delta_targets` is always drained (even when // `cur_const` is unset) so producers never leak into the next constant. if self.env.profile_sink.is_some() { + let touched = std::mem::take(&mut self.touched); + if std::env::var_os("IX_TOUCH_STATS").is_some() + && let Some(a) = self.cur_const.as_ref() + { + eprintln!("[touch] {} {}", a.hex(), touched.len()); + } let producers = std::mem::take(&mut self.delta_targets); // Always drain the op counters (even when `cur_const` is unset) so they // never leak into the next constant, mirroring `delta_targets`. let ops = crate::profile::take_op_counts(); if let Some(addr) = self.cur_const.take() { let sink = self.env.profile_sink.as_mut().unwrap(); - sink.record(addr, used, producers, ops); + sink.record(addr, used, producers, touched, ops); } } } From 3d481b450e537ef4e9f652b488aab2ced13b2973 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Mon, 3 Aug 2026 14:26:58 +0000 Subject: [PATCH 02/20] prove: batched, resumable all-shards mode with composed verdict MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit prove --ixe --ixes with no --shard now runs the whole partition through one EnvHandle + one AiurSystem instead of a fire-and-forget loop. Progress persists in the keyed cache ~/.ix/cache/shard-proofs/ (one entry per claim digest, holding the proof's store address): an entry is written only after the proof VERIFIES and binds to the shard's reconstructed CheckEnv claim digest, so a crash or OOM costs only the in-flight shard and re-running the same command resumes. Cached entries are re-verified on resume — the digest pins the claim, not the circuit version. The digest is manifest-independent, so manifests sharing a shard share its proof. Pending shards prove heaviest-predicted-RAM first (from the packer's costs sidecar): if the RAM model's blind spot is going to breach a box it is one of the heaviest shards, and proving those first surfaces the failure in the opening minutes instead of hours in. --jobs N proves shards concurrently (default 1 — each prove peaks at the shard's full predicted RAM). aiur: ExecError::InvalidIOKey now names the channel and key, so a witness that under-ships identifies the constant whose bytes are missing instead of failing generically. --- Ix/Cli/ProveCmd.lean | 171 +++++++++++++++++++++++++++++++++++-- Ix/Store.lean | 12 +++ crates/aiur/src/execute.rs | 20 ++++- 3 files changed, 192 insertions(+), 11 deletions(-) diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index a35609d9a..18bf71d8e 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -30,6 +30,7 @@ public import Ix.Aiur.Compiler public import Ix.Aiur.Protocol public import Ix.Claim public import Ix.Cli.CheckCmd +public import Ix.Cli.VerifyCmd public import Ix.Common public import Ix.IxVM public import Ix.IxVM.Toplevel @@ -53,6 +54,26 @@ private def commitmentParameters : Aiur.CommitmentParameters := private def friParameters : Aiur.FriParameters := Aiur.defaultFriParameters +/-- Resolve a keyed cache namespace: `/` when a root is + given (tests use a scratch root to stay hermetic), else the global + `~/.ix/cache/`. Entries are named by claim digest and hold + re-derivable state, so the directory is safe to wipe. -/ +def cacheSubdir (cacheRoot : Option System.FilePath) (ns : String) : + IO System.FilePath := do + match cacheRoot with + | some root => + let d := root / ns + IO.FS.createDirAll d + pure d + | none => StoreIO.toIO (Store.cacheDir ns) + +/-- Atomic keyed-cache write: `/` via temp file + rename. -/ +def writeCacheEntry (dir : System.FilePath) (key content : String) : + IO Unit := do + let tmp := dir / s!"{key}.tmp" + IO.FS.writeFile tmp content + IO.FS.rename tmp (dir / key) + def proveOne (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) (claim : Ix.Claim) @@ -138,6 +159,143 @@ def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle) let _ := manifestPath -- kept for parity with previous signature return 0 +/-- A shard proven, verified, and bound to its reconstructed claim; + persisted as the `shard-proofs/` cache entry. -/ +structure ProofRow where + shard : Nat + claimDigest : Address + proofAddr : Address + +/-- Batched, resumable all-shards prove — the whole-partition behavior of + `prove --ixes` with no `--shard`. + + One `EnvHandle`, one compiled toplevel, and one `AiurSystem` are shared + across every shard (the per-invocation setup is paid once). Progress + persists in the keyed cache `~/.ix/cache/shard-proofs/` (one file per + claim digest, holding the proof's store address): an entry is written + only after the shard's proof both VERIFIES and binds to the shard's + reconstructed `CheckEnv` claim digest, so a crash, OOM, or interrupt + costs only the in-flight shard and re-running the same command + resumes. The claim digest IS the staleness test — a repacked shard has + a new digest, which never matches an old entry — and it is + manifest-independent, so two manifests sharing a shard share its + proof. `cacheRoot` overrides `~/.ix/cache` (tests). + + `jobs` shards prove concurrently (default 1: each prove peaks at the + shard's full predicted RAM, so concurrency is a big-box knob). + + Ends with the composed verdict: disjoint cover + every shard bound to + a verified proof — the same statement `ix verify --ixe --ixes ` + checks after the fact. -/ +def runShardProveAllNative (manifestPath : String) (envHandle : Aiur.EnvHandle) + (ixonEnv : Ixon.Env) (shards : Array (Array Address)) + (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) + (jobs : Nat) (cacheRoot : Option System.FilePath := none) : IO UInt32 := do + if !(← Ix.Cli.CheckCmd.shardsCover ixonEnv shards) then return 1 + -- Reconstructed claim digest per shard: the binding target for proofs + -- and the cache key. + let mut digests : Array Address := #[] + for blocks in shards do + match Ix.Cli.CheckCmd.shardClaimDigest ixonEnv blocks with + | .error e => IO.eprintln s!"reconstruct shard {digests.size} claim failed: {e}"; return 1 + | .ok d => digests := digests.push d + let proofsDir ← cacheSubdir cacheRoot "shard-proofs" + -- Resume: a shard whose digest names a cache entry is done IF the + -- recorded proof still verifies — the digest pins the claim but not + -- the circuit version (any kernel change between sessions regenerates + -- the codegen and the verifying key), so trusting the entry alone + -- would count a stale-circuit proof. + let mut done : Std.HashMap Nat Address := {} + for k in [0:shards.size] do + let entry := proofsDir / toString digests[k]! + if ← entry.pathExists then + match Address.fromString (← IO.FS.readFile entry).trimAscii.toString with + | some pa => + if (← Ix.Cli.VerifyCmd.verifyOneProof aiurSystem compiled pa) == 0 then + done := done.insert k pa + else + IO.println s!"[prove] shard {k}: cached proof {pa} no longer \ + verifies (circuit changed?) — re-proving" + | none => pure () + let pending := (List.range shards.size).filter (fun k => !done.contains k) + -- Largest-predicted-RAM first. The RAM model carries a content residual + -- it cannot see (the klimbs blind spot), so if any shard is going to + -- breach the watchdog it is one of the heaviest — proving those first + -- surfaces a failure in the opening minutes instead of hours in, and + -- everything after the heavy head is strictly safer than what already + -- passed. Predictions come from the packer's costs sidecar; without + -- one, manifest order stands. + let pending : List Nat ← do + let costs := manifestPath ++ ".costs.csv" + if !(← System.FilePath.pathExists costs) then + IO.println s!"[prove] no costs sidecar ({costs}); proving in manifest order" + pure pending + else + -- `pred_ram_gib` is column 8 of the sidecar, printed with two + -- decimals, so dropping the dot yields centi-GiB as a Nat sort key. + let mut ram : Std.HashMap Nat Nat := {} + for line in (← IO.FS.readFile costs).splitOn "\n" do + let fs := line.splitOn "," + match fs[0]?.bind (·.toNat?), fs[8]?.bind (fun pr => (pr.replace "." "").toNat?) with + | some k, some centi => ram := ram.insert k centi + | _, _ => pure () + pure <| pending.mergeSort (fun a b => + (ram.get? a).getD 0 ≥ (ram.get? b).getD 0) + IO.println s!"[prove] {shards.size} shards: {done.size} already proven \ + (cache {proofsDir}), {pending.length} pending (heaviest first)" + let recordProof (r : ProofRow) : IO Unit := + writeCacheEntry proofsDir (toString r.claimDigest) s!"{r.proofAddr}\n" + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let proveOneShard (k : Nat) : IO (Except String ProofRow) := do + let blocks := shards[k]! + let blob := Id.run do + let mut b := ByteArray.empty + for a in Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks do + b := b ++ a.hash + pure b + IO.println s!"Proving shard {k}" + (← IO.getStdout).flush + match aiurSystem.shardProveWithEnv funIdx envHandle blob with + | .error e => return .error s!"shardProveWithEnv: {e}" + | .ok (claimBytes, proof, _outIO) => + match Ixon.runGet Ix.Claim.get claimBytes with + | .error e => return .error s!"claim wire-decode failed: {e}" + | .ok claim => + let d := Address.blake3 (Ix.Claim.ser claim) + if digests[k]? != some d then + return .error s!"proved claim {d} does not match reconstructed \ + digest {digests[k]!} — witness and reconstruction disagree" + let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) + let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } + let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + if (← Ix.Cli.VerifyCmd.verifyOneProof aiurSystem compiled proofAddr) != 0 then + return .error s!"proof {proofAddr} failed verification" + return .ok { shard := k, claimDigest := d, proofAddr } + let mut failures : List (Nat × String) := [] + for chunk in pending.toChunks (max 1 jobs) do + let tasks ← chunk.mapM fun k => + IO.asTask (prio := .dedicated) do pure (k, ← proveOneShard k) + for t in tasks do + match t.get with + | .ok (k, .ok row) => + recordProof row + done := done.insert k row.proofAddr + IO.println s!"[prove] shard {k}: proof {row.proofAddr} verified \ + ({done.size}/{shards.size})" + | .ok (k, .error e) => + IO.eprintln s!"[prove] shard {k} FAILED: {e}" + failures := (k, e) :: failures + | .error e => + IO.eprintln s!"[prove] task crashed: {e}" + failures := (shards.size, toString e) :: failures + if !failures.isEmpty then + IO.eprintln s!"[prove] {failures.length} shard(s) failed: \ + {failures.map (·.1)}; re-run the same command to resume" + return 1 + IO.println s!"[prove] OK: composed verdict — all {shards.size} shards \ + proven + verified + bound, disjoint cover" + return 0 + def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let keepGoing := p.hasFlag "keep-going" let ixePath : Option String := (p.flag? "ixe").map (·.as! String) @@ -163,20 +321,16 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do | .ok h => pure h runShardProveNative manifest envHandle ixonEnv shards k aiurSystem compiled false | some ixe, some manifest, none => - -- IxVM-native all-shards prove. Same envHandle reused across - -- every shard. + -- Batched, resumable all-shards prove (one env handle + one Aiur + -- system across every shard; progress in ~/.ix/cache/shard-proofs). match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixe) with | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => let envHandle ← match Aiur.EnvHandle.fromIxe ixe with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h - let mut rc : UInt32 := 0 - for k in [0 : shards.size] do - if (← runShardProveNative manifest envHandle ixonEnv shards k - aiurSystem compiled false) != 0 then - rc := 1 - pure rc + runShardProveAllNative manifest envHandle ixonEnv shards aiurSystem + compiled (((p.flag? "jobs").map (·.as! Nat)).getD 1) | _, _, _ => Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne @@ -193,6 +347,7 @@ def proveCmd : Cli.Cmd := `[Cli| "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, proves the persisted claim against the `--ixe` env (single proof, skips per-const iteration)." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: prove shard K. Without --shard: prove every shard in the partition." "shard" : Nat; "0-based shard index K (with --ixes and --ixe): prove that one shard's CheckEnv claim." + "jobs" : Nat; "Shards to prove concurrently in the all-shards batch (default 1). Each prove peaks at the shard's full predicted RAM, so raise this only when the box fits several shards at once." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to prove. With none, iterate every named constant in the env (sorted)." diff --git a/Ix/Store.lean b/Ix/Store.lean index 08c323be4..5f37dc67f 100644 --- a/Ix/Store.lean +++ b/Ix/Store.lean @@ -38,6 +38,18 @@ def storeDir : StoreIO FilePath := do IO.toEIO .ioError (IO.FS.createDirAll path) return path +/-- `~/.ix/cache/` — keyed, wipeable derived state, distinct + from the content-addressed store: filenames are lookup keys (claim + digests), contents are re-derivable or re-verifiable, and deleting + the directory only costs recomputation. Used for the shard-prove + resume ledger (`shard-proofs`). -/ +def cacheDir (namespace' : String) : StoreIO FilePath := do + let home ← getHomeDir + let path := home / ".ix" / "cache" / namespace' + if !(<- path.pathExists) then + IO.toEIO .ioError (IO.FS.createDirAll path) + return path + def storePath (addr: Address): StoreIO FilePath := do let store <- storeDir let hex := hexOfBytes addr.hash diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 69e03e12c..d4284b9c4 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -58,7 +58,16 @@ impl IOBuffer { channel: G, key: &[G], ) -> Result<&IOKeyInfo, ExecError> { - self.map.get(&(channel, key.to_vec())).ok_or(ExecError::InvalidIOKey) + self.map.get(&(channel, key.to_vec())).ok_or_else(|| { + // Name the channel and key: a missing witness entry is otherwise + // indistinguishable from any other, and the key identifies the + // constant or blob whose bytes the host failed to seed. + let hex: String = key + .iter() + .map(|g| format!("{:02x}", g.as_canonical_u64() & 0xff)) + .collect(); + ExecError::InvalidIOKey { channel: channel.as_canonical_u64(), key: hex } + }) } fn set_info( &mut self, @@ -123,7 +132,10 @@ pub enum ExecError { MatchNoCase(u64), NoContinuation, StackNotEmpty, - InvalidIOKey, + InvalidIOKey { + channel: u64, + key: String, + }, IOMappingAlreadySet, IOReadOutOfBounds { idx: usize, @@ -165,7 +177,9 @@ impl std::fmt::Display for ExecError { Self::StackNotEmpty => { write!(f, "exec entries stack not empty at return") }, - Self::InvalidIOKey => write!(f, "invalid IO key"), + Self::InvalidIOKey { channel, key } => { + write!(f, "invalid IO key: channel {channel}, key {key}") + }, Self::IOMappingAlreadySet => write!(f, "IO mapping already set for key"), Self::IOReadOutOfBounds { idx, len } => { write!(f, "IO read out of bounds: idx={idx}, len={len}") From 19ad8aa71a196b6e84becc2ae20e25bde35f4dad Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Mon, 3 Aug 2026 14:26:58 +0000 Subject: [PATCH 03/20] bench: aiur-shard backend, Init env, shard-pipeline E2E test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit aiur-shard bench backend: profile the env's touch graph, pack at a pinned machine-independent budget (aiurShardBudgetGb = 250, the deliverable prove box — a PR row and its baseline must describe the same partition problem), upload planner metrics (shards, pred-floor-ram, union-bytes) on tight 5% upper bands (profile worker interleaving wobbles touch sets ±2 shards, so no exact pins), then execute the three heaviest-predicted shards through the native kernel and aggregate count-neutral heavy-execute-time / heavy-peak-rss. ix check gains --json/--json-name so a shard check self-reports its bench row with the env parse excluded from the timed window. Init is registered as a benchmark env — it is the shard pipeline's deliverable partition, so its planner trend line matters on its own. Tests/Ix/Kernel/ShardPipeline.lean: end-to-end regression over a small multi-shard env — profile → pack (disjoint cover) → every shard checks → batched prove reaches the composed verdict → second run resumes from the shard-proofs cache with zero pending. Runs under a scratch cache root, never the global ~/.ix/cache; wired into the ixvm suite. --- .../workflows/bencher-thresholds-reset.yml | 8 +- Ix/Cli/BenchCmd.lean | 127 +++++++++++++++++- Ix/Cli/BenchPlots.lean | 18 ++- Ix/Cli/CheckCmd.lean | 34 ++++- Tests/Ix/Kernel/ShardPipeline.lean | 106 +++++++++++++++ Tests/Main.lean | 8 +- 6 files changed, 289 insertions(+), 12 deletions(-) create mode 100644 Tests/Ix/Kernel/ShardPipeline.lean diff --git a/.github/workflows/bencher-thresholds-reset.yml b/.github/workflows/bencher-thresholds-reset.yml index b4b5947fd..c5a003002 100644 --- a/.github/workflows/bencher-thresholds-reset.yml +++ b/.github/workflows/bencher-thresholds-reset.yml @@ -22,7 +22,7 @@ name: Bencher thresholds reset # cancel by removing it before merge. Naming convention: one label per token, # `bencher-thresholds-reset:` where is a workload (a backend # testbed in Ix/Cli/BenchCmd.lean (backendSpecs) minus its runner-arch suffix: -# `ix-compile`, `ix-decompile`, `aiur-check-execute`, `aiur-check-prove`, `aiur-check-recursive`, `aiur-recursive`, `zisk-check-execute`, `sp1-check-execute`, `ooc-check`) or +# `ix-compile`, `ix-decompile`, `aiur-check-execute`, `aiur-check-prove`, `aiur-check-recursive`, `aiur-recursive`, `aiur-shard`, `zisk-check-execute`, `sp1-check-execute`, `ooc-check`) or # `all` (the merge step expands an `all` label into every workload). Labeling # requires Triage+, so PR authors from forks cannot self-queue a reset. The # label shares the command/workflow name; the ref it moves is @@ -44,7 +44,7 @@ on: # GitHub requires literal choice options, so this list stays static: # keep it (and the jobs' valid= lists below) in sync with the # backend testbeds in Ix/Cli/BenchCmd.lean (backendSpecs). - options: [ix-compile, ix-decompile, aiur-check-execute, aiur-check-prove, aiur-check-recursive, aiur-recursive, zisk-check-execute, sp1-check-execute, ooc-check, all] + options: [ix-compile, ix-decompile, aiur-check-execute, aiur-check-prove, aiur-check-recursive, aiur-recursive, aiur-shard, zisk-check-execute, sp1-check-execute, ooc-check, all] sha: description: "Commit to anchor to (default: HEAD)" required: false @@ -77,7 +77,7 @@ jobs: # (backendSpecs) minus the runner-arch suffix. Static because this # job runs on a cheap runner with no built `ix`; keep in sync when # adding a backend. - valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" + valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive aiur-shard ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" if [ "$EVENT" = workflow_dispatch ]; then # Reset the chosen workload(s) at the given commit; no PR scan. sha="${INPUT_SHA:-$HEAD_SHA}" @@ -133,7 +133,7 @@ jobs: # which the merge job expands into every workload). Same static # list as the reset job; keep both in sync with backendSpecs in # Ix/Cli/BenchCmd.lean. - valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" + valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive aiur-shard ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" accepted="$valid all" # Parse the workload token(s) after the command, lowercased. workloads=$(printf '%s' "$BODY" \ diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean index b54814f95..469fda642 100644 --- a/Ix/Cli/BenchCmd.lean +++ b/Ix/Cli/BenchCmd.lean @@ -131,6 +131,10 @@ structure EnvSpec where module : String def envSpecs : List EnvSpec := [ + -- Init is the Aiur shard pipeline's deliverable env (the partition the + -- full-Init proof runs over), so its planner trend line matters on its + -- own — InitStd's does not subsume it. + { name := "Init", module := "Benchmarks/Compile/CompileInit.lean" }, { name := "InitStd", module := "Benchmarks/Compile/CompileInitStd.lean" }, { name := "Lean", module := "Benchmarks/Compile/CompileLean.lean" }, { name := "Mathlib", module := "Benchmarks/Compile/CompileMathlib.lean" }, @@ -273,6 +277,30 @@ def backendSpecs : List BackendSpec := [ ("recursive-proof-size", "0.05", "_"), ("prove-time", "0.10", "_"), ("proof-size", "0.05", "_"), ("verify-time", "0.10", "_"), ("peak-rss", "0.10", "_")] }, + -- The Aiur shard pipeline: profile the env's touch graph, pack at the + -- pinned budget (`aiurShardBudgetGb`), execute the three + -- heaviest-predicted shards through the native kernel — the regime the + -- per-constant aiur rows never enter (a single-constant run faults a + -- tiny closure). The planner metrics only drop on a real ingress/packer + -- win, but they are NOT exactly reproducible — profile worker + -- interleaving wobbles the touch sets a little (measured ±2 shards on + -- InitStd's ~118) — so they ride tight 5% upper bands instead of pins; + -- a real regression (or win) moves them by integer factors. + -- pred-floor-ram sits at the pack cap whenever the env is larger than + -- one shard, so its band guards CAP OVERFLOW (an atomic block packed + -- above budget), not ordinary growth; it is tracked but not plotted — + -- the heavy execution measures the real thing. heavy-* slugs are + -- count-neutral (mean time / max RSS over the sample) so the trend + -- lines survive tuning the sample size. Plan wall time is logged by + -- the run, not uploaded — a diagnostic, not a trend. + { name := "aiur-shard", defaultMode := "execute", inputs := .perEnv, + testbeds := [("execute", "aiur-shard-x64-32x")], + metrics := [("execute", ["shards", "pred-floor-ram", "union-bytes", + "heavy-execute-time", "heavy-peak-rss"])], + thresholds := [("shards", "0.05", "_"), ("pred-floor-ram", "0.05", "_"), + ("union-bytes", "0.05", "_"), + ("heavy-execute-time", "0.10", "_"), + ("heavy-peak-rss", "0.10", "_")] }, { name := "zisk", defaultMode := "execute", inputs := .perConstant, testbeds := [("execute", "zisk-check-execute-x64-32x")], metrics := [("execute", ["execute-time", "throughput", "peak-rss", @@ -356,6 +384,14 @@ def findBackend (name : String) : Option BackendSpec := def recursiveConstants : List String := ["Nat.add_comm"] +/-- `aiur-shard`'s pinned packing budget (GiB). Machine-independent on + purpose: a PR row and its bencher baseline must describe the same + partition problem, so the budget is the deliverable 256 GB prove + box — NOT the runner's own RAM (`--ceiling-gb` still guards the + runner). Executing a shard needs a small fraction of its predicted + PROVE RAM, so heavy-three execution fits hosts the prove would not. -/ +def aiurShardBudgetGb : Nat := 250 + def BackendSpec.testbedFor (b : BackendSpec) (mode : String) : Option String := (b.testbeds.find? (·.1 == mode)).map (·.2) @@ -803,6 +839,93 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do runGuarded watchdog ceilingGb bt #["--ixe", ixe, "--consts", name, "--json", out, "--texray", "--recursive"] + | "aiur-shard" => + if mode != "execute" then + p.printError s!"error: {backend} supports only execute mode" + return exitUsage + let ixe ← ensureIxe repo info ((p.flag? "ixe").map (·.as! String)) + let ix ← resolveBin repo "ix" + let prof := s!"{repo}/{env}-shardbench.ixprof" + let manifest := s!"{repo}/{env}-shardbench.ixes" + let budget := (p.flag? "shard-budget").map (·.as! Nat) + |>.getD aiurShardBudgetGb + -- Plan: profile (touch graph) + pack. Wall time is logged, not + -- uploaded — a diagnostic, not a tracked trend. + let t0 ← IO.monoMsNow + let e1 ← runGuarded watchdog ceilingGb ix + #["profile", ixe, "--out", prof, "--backend", "aiur"] + if e1 != 0 then + IO.eprintln s!"[bench] ix profile failed (exit {e1})" + return 1 + let e2 ← runGuarded watchdog ceilingGb ix + #["shard", prof, "--backend", "aiur", "--max-ram", toString budget, + "--out", manifest] + if e2 != 0 then + IO.eprintln s!"[bench] ix shard failed (exit {e2})" + return 1 + IO.eprintln s!"[bench] plan (profile + pack) took {((← IO.monoMsNow) - t0).toFloat / 1000.0}s" + -- The packer's costs sidecar, one row per shard: + -- `shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,pred_ram_gib,pred_prove_s`. + -- `pred_ram_gib` prints with two decimals, so dropping the dot yields + -- centi-GiB as a Nat sort key. + let mut planRows : Array (Nat × Nat × Nat) := #[] -- (shard, centiGiB, unionBytes) + for line in (← IO.FS.readFile (manifest ++ ".costs.csv")).splitOn "\n" do + match line.splitOn "," with + | [k, union, _, _, _, _, _, _, pr, _] => + match k.toNat?, union.toNat?, ((pr.replace "." "").toNat?) with + | some k, some u, some c => planRows := planRows.push (k, c, u) + | _, _, _ => pure () + | _ => pure () + if planRows.isEmpty then + IO.eprintln s!"[bench] no shard rows parsed from {manifest}.costs.csv" + return 1 + let floorCenti := planRows.foldl (fun m r => max m r.2.1) 0 + let unionBytes := planRows.foldl (fun s r => s + r.2.2) 0 + writeRow out info.name "ok" + [ ("shards", Lean.toJson planRows.size) + , ("pred-floor-ram", jsonRound 2 (floorCenti.toFloat / 100.0)) + , ("union-bytes", Lean.toJson unionBytes) ] + -- Execute the three heaviest-predicted shards — where a model miss or + -- kernel regression hits first, and where an ingress win is largest. + -- One process per shard (a kill costs that shard); the tool excludes + -- its env parse from the timed window and self-reports the row. A + -- kill (≥128) records `oom`/`crash` and the walk continues; any other + -- nonzero exit is a genuine kernel rejection and fails the run. + let byWeight := planRows.qsort (fun a b => a.2.1 > b.2.1) + let mut greens : Array String := #[] + for r in byWeight.extract 0 3 do + let rowName := s!"{info.name}/shard-{r.1}" + let exit ← runGuarded watchdog ceilingGb ix + #["check", "--ixe", ixe, "--ixes", manifest, "--shard", toString r.1, + "--json", out, "--json-name", rowName] + if exit == 0 then + greens := greens.push rowName + else if exit ≥ 128 then + let status := killStatus exit + IO.eprintln s!"[bench] '{rowName}' killed (exit {exit}); recording {status}" + markKilled out rowName status + else + IO.eprintln s!"[bench] '{rowName}' failed to check (exit {exit})" + return 1 + -- Headline aggregates on the env row, absent unless all three heavy + -- sub-rows completed — a missing aggregate (an OOM'd shard) is the + -- honest signal. Mean time and max RSS, not sums: count-robust, so + -- the sample size is a tuning knob and not part of the measures' + -- identity. + let rows ← readRows out + let getF (row : Lean.Json) (key : String) : Option Float := + match (row.getObjVal? key).toOption with + | some (.num n) => some n.toFloat + | _ => none + let subs := greens.filterMap fun n => (rows.getObjVal? n).toOption + let times := subs.filterMap (getF · "execute-time") + let rsss := subs.filterMap (getF · "peak-rss") + IO.eprintln s!"[bench] heavy walk: {greens.size}/3 green" + if times.size == 3 && rsss.size == 3 then + if let some envRow := (rows.getObjVal? info.name).toOption then + writeEntry out info.name <| (envRow.setObjVal! "heavy-execute-time" + (jsonRound 3 ((times.foldl (· + ·) 0.0) / times.size.toFloat))).setObjVal! + "heavy-peak-rss" (jsonRound 0 (rsss.foldl max 0.0)) | "zisk" | "sp1" => if mode != "execute" then p.printError s!"error: {backend} supports only execute mode" @@ -854,6 +977,7 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do let expected := match backend with | "compile" => #[info.name] | "decompile" => #[info.name] + | "aiur-shard" => #[info.name] | "ooc" | "lean4lean" => #[info.name] ++ names | "aiur-recursive" => recursiveConstants.toArray | _ => names @@ -898,7 +1022,7 @@ def benchRunCmd : Cli.Cmd := `[Cli| "Execute one benchmark run (backend × env × mode), writing benchmark results JSON. Exits 0 on success (rows saved as the local baseline), 3 when the kernel rejected any constant, 1 when no rows were produced." FLAGS: - backend : String; "aiur | zisk | sp1 | ooc | lean4lean | compile | decompile | aiur-recursive" + backend : String; "aiur | aiur-shard | zisk | sp1 | ooc | lean4lean | compile | decompile | aiur-recursive" env : String; "Benchmark env from the registry (default: InitStd)" mode : String; "prove | execute | recursive (default: the backend's defaultMode)" out : String; "Benchmark results JSON output path (default: bench.json)" @@ -910,6 +1034,7 @@ def benchRunCmd : Cli.Cmd := `[Cli| "shard-only"; "Restrict to shard_target rows" ixe : String; "Path to an existing .ixe env to use (default: compile fresh; ignored by the compile backend)" "ceiling-gb" : Nat; "RAM watchdog ceiling in GB (default: machine RAM minus 15 GB)" + "shard-budget" : Nat; "aiur-shard only: pinned `ix shard --max-ram` packing budget in GiB (default 250, the deliverable prove box). Change it only knowingly — the bencher baseline is keyed to the same partition problem." watchdog : String; "Watchdog wrapper path (default: /.github/scripts/watchdog.sh; missing = run unguarded)" ] diff --git a/Ix/Cli/BenchPlots.lean b/Ix/Cli/BenchPlots.lean index a53b6e31c..361daaea0 100644 --- a/Ix/Cli/BenchPlots.lean +++ b/Ix/Cli/BenchPlots.lean @@ -81,6 +81,10 @@ def plotTitle (workload measure : String) : String := | "aiur-recursive", "recursive-peak-rss" => "Aiur Recursive Verifier Peak RAM Usage" | "aiur-recursive", "recursive-proof-size" => "Aiur Recursive Verifier Proof Size" | "aiur-recursive", "recursive-fft-cost" => "Aiur Recursive Verifier FFT Cost" + | "aiur-shard", "shards" => "Aiur Predicted Shards" + | "aiur-shard", "union-bytes" => "Aiur Shard Ingress Bytes" + | "aiur-shard", "heavy-execute-time" => "Aiur Heavy-Shard Execute Time" + | "aiur-shard", "heavy-peak-rss" => "Aiur Heavy-Shard Peak RAM Usage" | w, m => s!"{w}: {m}" /-- Tracked but not plotted solo. The two aiur runs re-measure each @@ -98,13 +102,17 @@ def plotTitle (workload measure : String) : String := IxVM typecheck proof (under recursion-tuned parameters) — tracked for the compare table, but the dashboard trend that matters is the recursion layer's own `recursive-*` series, so the inner metrics - aren't plotted. -/ + aren't plotted. aiur-shard's + `pred-floor-ram` is a cap-overflow tripwire (thresholded), while the + heavy-three execution charts the real RAM — the prediction adds no + dashboard trend of its own. -/ def plotSkips : List (String × String) := [("aiur-check-prove", "execute-time"), ("aiur-check-execute", "fft-cost"), ("zisk-check-execute", "shards"), ("zisk-check-execute", "constants"), ("ix-decompile", "file-size"), ("ix-decompile", "constants"), ("aiur-recursive", "prove-time"), ("aiur-recursive", "proof-size"), - ("aiur-recursive", "verify-time"), ("aiur-recursive", "peak-rss")] + ("aiur-recursive", "verify-time"), ("aiur-recursive", "peak-rss"), + ("aiur-shard", "pred-floor-ram")] /-- Canonical units per measure slug, asserted on every sync: bencher auto-creates a measure with placeholder units ("Measure (units)") on @@ -127,6 +135,10 @@ def unitsFor (slug : String) : Option String := ("cycles", "cycles"), ("max-shard-cycles", "cycles"), ("shards", "shards"), + ("pred-floor-ram", "GiB"), + ("union-bytes", "bytes (B)"), + ("heavy-execute-time", "seconds (s)"), + ("heavy-peak-rss", "bytes (B)"), ("fft-cost", "FFTs"), ("recursive-execute-time", "seconds (s)"), ("recursive-prove-time", "seconds (s)"), @@ -140,7 +152,7 @@ def unitsFor (slug : String) : Option String := ooc); unranked workloads (a future backend) sort last. -/ def workloadOrder : List String := ["ix-compile", "ix-decompile", "aiur-check-prove", "aiur-check-execute", - "aiur-recursive", "zisk-check-execute", "ooc-check"] + "aiur-recursive", "aiur-shard", "zisk-check-execute", "ooc-check"] structure PlotSpec where testbed : String diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 565538782..e83f795e7 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -24,6 +24,7 @@ public import Ix.Aiur.Interpret public import Ix.Aiur.Protocol public import Ix.Aiur.Statistics public import Ix.AssumptionTree +public import Ix.Benchmark.Results public import Ix.Claim public import Ix.Common public import Ix.IxVM @@ -32,6 +33,7 @@ public import Ix.IxVM.ClaimHarness public import Ix.Ixon public import Ix.Meta public import Ix.Store +public import Ix.TracingTexray public import Ix.Cli.NameResolve public section @@ -484,7 +486,8 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) once for this one call. -/ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (useBytecode : Bool) : IO UInt32 := do + (statsOut : Option String) (useBytecode : Bool) + (benchJson : Option (String × String) := none) : IO UInt32 := do match (← loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => match shards[shardK]? with @@ -493,7 +496,26 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 | .ok h => pure h - runShardOwnedNative envHandle compiled printStats statsOut useBytecode ixonEnv blocks shardK + -- `benchJson = (out, rowName)` reports the check as a benchmark row + -- (the `aiur-shard` bench backend's per-shard spawn): `execute-time` + -- windows the check itself — the env parse and `EnvHandle` build are + -- excluded, so the measure tracks the kernel, not the loader — while + -- `peak-rss` is the process tree's absolute high-water (the parsed + -- env sits in the baseline, matching the ooc rows' semantics). + if benchJson.isSome then + TracingTexray.startSampler + TracingTexray.resetPeakTreeRss + let start ← IO.monoMsNow + let rc ← runShardOwnedNative envHandle compiled printStats statsOut + useBytecode ixonEnv blocks shardK + if let some (out, rowName) := benchJson then + if rc == 0 then + let secs := ((← IO.monoMsNow) - start).toFloat / 1000.0 + let peakRss ← TracingTexray.peakTreeRssBytes + Ix.Benchmark.Results.writeRow out rowName "ok" + [ ("execute-time", Ix.Benchmark.Results.jsonRound 3 secs) + , ("peak-rss", Lean.toJson peakRss) ] + return rc /-- Coverage check over already-loaded env + shards: every constant's check-schedule block is owned by **exactly one** shard. That is the whole @@ -672,7 +694,11 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c - return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut useBytecode) + let benchJson := (p.flag? "json").map fun f => + (f.as! String, + ((p.flag? "json-name").map (·.as! String)).getD s!"shard-{k}") + return (← runShardCheckManifestNative manifest ixe k compiled printStats + statsOut useBytecode benchJson) | some ixe, some manifest, none => if interpSource then return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) @@ -702,6 +728,8 @@ def checkCmd : Cli.Cmd := `[Cli| "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; "Max shards to check concurrently when checking a whole partition (--ixes without --shard). Default: all at once. Lower it to bound peak RAM — each in-flight shard re-ingests its closure into its own IO buffer." + json : String; "Benchmark results JSON accumulator (single-shard mode only): append an `execute-time`/`peak-rss` row for the checked shard. Used by `ix bench run --backend aiur-shard`." + "json-name" : String; "Row name for --json (default: shard-)." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to check. With none, iterate every named constant in the env (sorted)." diff --git a/Tests/Ix/Kernel/ShardPipeline.lean b/Tests/Ix/Kernel/ShardPipeline.lean new file mode 100644 index 000000000..3858b5a19 --- /dev/null +++ b/Tests/Ix/Kernel/ShardPipeline.lean @@ -0,0 +1,106 @@ +/- + End-to-end regression for the Aiur shard pipeline: + + Lean env → .ixe → `ix profile` (touch graph) → `ix shard` + (measured packing) → check every shard → batch prove + (prove → verify → bind) → composed verdict → resume. + + The suite pins: + + - the packer produces a disjoint cover over a fresh touch-graph + profile; + - every shard CHECKS through the native kernel; + - the batched prove reaches the composed verdict: every proof + VERIFIES and binds to its shard's reconstructed claim; + - the shard-proofs cache makes the run resumable (second run: 0 + pending), exercising the entry re-verification path. + + Artifacts live under `.lake/tmp-shard-pipeline/` (wiped per run), + including a scratch cache root so the test never touches the global + `~/.ix/cache`; proofs land in the content-addressed store like any + prove. +-/ +import Ix.Meta +import Ix.Aiur.Protocol +import Ix.IxVM +import Ix.IxVM.ClaimHarness +import Ix.Ixon +import Ix.KernelCheck +import Ix.Cli.CheckCmd +import Ix.Cli.ProveCmd +import Ix.Cli.VerifyCmd +import LSpec + +open LSpec + +namespace Tests.Ix.Kernel.ShardPipeline + +/-- Small but non-trivial roots: enough closure (~200 consts) to pack + several shards at a small budget, with inductives, recursors, and + string/Nat literals represented. -/ +private def roots : Array Lean.Name := + #[`Nat.add, `List.append, `Nat.mul, `Char.ofNat] + +private def dir : System.FilePath := ".lake" / "tmp-shard-pipeline" + +def shardPipelineTests (env : Lean.Environment) + (compiled : Aiur.CompiledToplevel) : IO TestSeq := do + IO.FS.createDirAll dir + let ixe := dir / "pipeline.ixe" + let prof := dir / "pipeline.ixprof" + let ixes := dir / "pipeline.ixes" + let cacheRoot := dir / "cache" + for f in [ixe, prof, ixes] do + if ← f.pathExists then IO.FS.removeFile f + if ← cacheRoot.pathExists then IO.FS.removeDirAll cacheRoot + + -- Lean env → .ixe + let ixonEnv ← IxVM.ClaimHarness.loadSharedIxonEnv roots env + let bytes ← IO.ofExcept (Ixon.serEnv ixonEnv) + IO.FS.writeBinFile ixe bytes + + -- .ixe → touch-graph profile → measured manifest. The tiny budget + -- forces a multi-shard partition so cross-shard frontiers exist. + Ix.KernelCheck.rsProfileAnonFFI ixe.toString prof.toString true true "0" "aiur" + Ix.KernelCheck.rsShardEspCapFFI prof.toString "0" "6" "5" "1" + ixes.toString "aiur" + + let (parsedEnv, shards) ← + match ← Ix.Cli.CheckCmd.loadEnvAndShards ixes.toString ixe.toString with + | .error e => throw <| IO.userError s!"manifest/env load failed: {e}" + | .ok r => pure r + let mut tests : TestSeq := + test s!"packer produced a multi-shard partition ({shards.size})" + (shards.size ≥ 2) + + -- Every shard checks through the native kernel. + let checkRc ← Ix.Cli.CheckCmd.runShardManifestAllNative ixes.toString + ixe.toString none compiled false none false + tests := tests ++ test "all shards check" (checkRc == 0) + + -- Batched prove: prove → verify → bind → compose. + let (aiurSystem, compiled') ← match ← Ix.Cli.VerifyCmd.buildBackend with + | .error e => throw <| IO.userError s!"backend build failed: {e}" + | .ok b => pure b + let envHandle ← match Aiur.EnvHandle.fromIxe ixe.toString with + | .error e => throw <| IO.userError s!"EnvHandle.fromIxe: {e}" + | .ok h => pure h + let proveRc ← Ix.Cli.ProveCmd.runShardProveAllNative ixes.toString envHandle + parsedEnv shards aiurSystem compiled' 1 (some cacheRoot) + tests := tests ++ test "batch prove reaches the composed verdict" (proveRc == 0) + let cacheEntries (ns : String) : IO Nat := do + if !(← (cacheRoot / ns).pathExists) then return 0 + return (← (cacheRoot / ns).readDir).size + tests := tests ++ test + s!"shard-proofs cache written ({← cacheEntries "shard-proofs"} entries)" + ((← cacheEntries "shard-proofs") == shards.size) + + -- Resume: every cached proof must re-verify and be skipped; verdict + -- unchanged. + let resumeRc ← Ix.Cli.ProveCmd.runShardProveAllNative ixes.toString envHandle + parsedEnv shards aiurSystem compiled' 1 (some cacheRoot) + tests := tests ++ test "resume re-verifies cached proofs and stays green" + (resumeRc == 0) + pure tests + +end Tests.Ix.Kernel.ShardPipeline diff --git a/Tests/Main.lean b/Tests/Main.lean index 3eab7ece7..17ec330fd 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -26,6 +26,7 @@ import Tests.Ix.Kernel.Roundtrip import Tests.Ix.Kernel.RoundtripNoCompile import Tests.Ix.Kernel.Tutorial import Tests.Ix.Kernel.Arena +import Tests.Ix.Kernel.ShardPipeline import Tests.Ix.Kernel.PrimAddrs import Tests.Ix.RustSerialize import Tests.Ix.RustDecompile @@ -225,9 +226,14 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ pure (LSpec.test s!"Shard pipeline FFT matches: expected 10817625733, got {actual}" (actual = 10_785_479_733)) + -- Full planner-to-composed-verdict E2E: profile → pack → check + -- every shard → batched prove with resume. + let shardPipeSeq ← + Tests.Ix.Kernel.ShardPipeline.shardPipelineTests env v2Env.compiled LSpec.lspecIO (.ofList [("ixvm", - [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []), + [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq, + shardPipeSeq])]) []), ("validate-aux", runCompileValidateAux env), -- Cross-compiler differential over the same fixture corpus: pure-Lean -- Ix.CompileM per-block vs Rust, root-cause classified (see From f7820714205407b199bfc6d46db841be64b534ec Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Mon, 3 Aug 2026 14:36:46 +0000 Subject: [PATCH 04/20] =?UTF-8?q?shard:=20per-shard=20rebudget=20=E2=80=94?= =?UTF-8?q?=20surgical=20split=20of=20one=20shard,=20cached=20proofs=20pre?= =?UTF-8?q?served?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ix shard --rebudget K --manifest M.ixes --max-ram G --backend aiur packs only shard K's blocks at the child budget (in the original cut-coherent order); every other shard's block list is reproduced verbatim — asserted, because ShardManifest::build is deterministic in (profile, assignment) and that identity is exactly what keeps the untouched shards' claim digests, and therefore their ~/.ix/cache/shard-proofs entries, valid. The first child keeps id K, the rest append; the aggregation tree's leaf K becomes a left-leaning chain over the children. The costs sidecar is recomputed for every row (identical for untouched shards — the faulted-set union is a function of the owned set alone), so heaviest- first prove ordering picks up the children's predictions. This is the recourse when the RAM model's blind spot packs an outlier shard past what the box can prove: a global repack at a lower budget shifts boundaries from early in the pack order and forfeits most of the proof cache, while a rebudget costs exactly the split shard. Ported from the sb/sp1-shard-agg experiment (where a 148-predicted shard measured ~248 GiB); simplified for the owned-only manifest — the promotion-inheritance step is gone because the witness ships the full closure and a child can never miss an IO key. --- Ix/Cli/ShardCmd.lean | 23 +++ Ix/KernelCheck.lean | 15 ++ crates/ffi/src/kernel.rs | 41 +++++ crates/kernel/src/shard.rs | 365 ++++++++++++++++++++++++++++++++++++- 4 files changed, 439 insertions(+), 5 deletions(-) diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index c3c87f4ae..151607ce4 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -102,6 +102,27 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do p.printError s!"error: --backend must be zisk or aiur (got {backend})" return 1 + -- Surgical single-shard split: `--rebudget K --manifest M.ixes --max-ram G`. + -- Every other shard is copied verbatim (cached proofs stay valid); shard K + -- is replaced by children packed at the smaller budget. + match (p.flag? "rebudget").map (·.as! Nat) with + | some k => + let manifestIn := (p.flag? "manifest").map (·.as! String) |>.getD "" + if manifestIn.isEmpty then + p.printError "error: --rebudget needs --manifest (the input .ixes to split)" + return 1 + match maxRam with + | none => + p.printError "error: --rebudget needs --max-ram (per-child budget, GiB)" + return 1 + | some g => + IO.println s!"Rebudgeting shard {k} of {manifestIn} at {g} GiB per child" + rsShardRebudgetFFI espPath manifestIn (toString k) (toString g) + (toString balancePct) outPath + IO.println s!"[shard] wrote {outPath}" + return 0 + | none => pure () + -- Precedence: explicit --shards (fixed count) > explicit --max-cycles/--max-ram -- (budget) > default (size to detected system RAM). match shardsFlag with @@ -137,6 +158,8 @@ def shardCmd : Cli.Cmd := `[Cli| balance : Nat; "Per-bisection balance tolerance, percent (default 5)" parallelism : Nat; "Provers assumed for the prove-time estimate (default 1 = sequential)" backend : String; "Packing cost model: zisk (default, guest-STEP cap) or aiur (RAM model; use with --max-ram)" + rebudget : Nat; "Surgically split shard K of --manifest at the smaller --max-ram budget; every other shard is copied verbatim so its cached claims/proofs stay valid." + manifest : String; "Input .ixes manifest to split (with --rebudget)." out : String; "Output .ixes manifest path (default: .ixes, e.g. init.ixprof → init.ixes)" ARGS: diff --git a/Ix/KernelCheck.lean b/Ix/KernelCheck.lean index d8e04c8a8..a24592416 100644 --- a/Ix/KernelCheck.lean +++ b/Ix/KernelCheck.lean @@ -257,6 +257,21 @@ opaque rsShardEspCapFFI : @& String → -- backend cost model (zisk|aiur) IO Unit +/-- FFI: surgically split ONE shard of an existing Aiur `.ixes` manifest at a + smaller per-shard RAM budget. Every other shard's block list is copied + verbatim (their claims and cached proofs stay valid); shard `k` is + replaced by its children (the first child keeps id `k`, the rest append + at the end). -/ +@[extern "rs_shard_rebudget"] +opaque rsShardRebudgetFFI : + @& String → -- .ixprof path + @& String → -- input .ixes manifest path + @& String → -- shard index to split + @& String → -- per-child RAM budget GiB + @& String → -- balance percent + @& String → -- output .ixes path + IO Unit + end Ix.KernelCheck end diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 9d32294c6..5a55246ee 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -3197,6 +3197,47 @@ pub extern "C" fn rs_shard_esp_cap( } } +/// FFI: surgically split ONE shard of an existing Aiur `.ixes` manifest at a +/// smaller per-shard RAM budget. Every other shard's block list is copied +/// verbatim (their claims and cached proofs stay valid); shard `k` is +/// replaced by its children (first child keeps id `k`, the rest append at +/// the end). +#[unsafe(no_mangle)] +pub extern "C" fn rs_shard_rebudget( + esp_path: LeanString>, + manifest_path: LeanString>, + shard_k: LeanString>, + ram_gb: LeanString>, + balance_pct: LeanString>, + out_path: LeanString>, +) -> LeanIOResult { + let k = match shard_k.to_string().parse::() { + Ok(k) => k, + Err(_) => return LeanIOResult::error_string("rebudget: bad shard index"), + }; + let ram = ram_gb.to_string().parse::().unwrap_or(0.0); + if ram <= 0.0 { + return LeanIOResult::error_string( + "rebudget: pass a positive per-child RAM budget (GiB)", + ); + } + let balance = balance_pct.to_string().parse::().unwrap_or(5.0) / 100.0; + match ix_kernel::shard::rebudget_manifest_shard( + &esp_path.to_string(), + &manifest_path.to_string(), + k, + ram, + balance, + &out_path.to_string(), + ) { + Ok(report) => { + eprintln!("[rs_shard_rebudget]\n{report}"); + LeanIOResult::ok(LeanOwned::box_usize(0)) + }, + Err(e) => LeanIOResult::error_string(&format!("rs_shard_rebudget: {e}")), + } +} + #[cfg(test)] mod tests { use super::{compact_in_flight_label, resolve_kernel_check_workers_from}; diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index f2af703fd..9b20df109 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -75,7 +75,7 @@ clippy::needless_range_loop )] -use rustc_hash::FxHashSet; +use rustc_hash::{FxHashMap, FxHashSet}; use std::cmp::Reverse; use std::collections::BinaryHeap; use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering}; @@ -1741,6 +1741,291 @@ pub fn shard_esp_aiur( )) } +/// Greedy next-fit packing of one block subset to a RAM cap, with the same +/// faulted-set union accounting as [`partition_for_aiur_ram`]'s packing walk +/// (measured touch sets when the profile has them, reference-closure BFS +/// otherwise). Returns the children as block-id lists, in pack order. +fn pack_block_subset_to_cap( + profile: &BlockProfile, + blocks_in_order: &[u32], + cap_gib: f64, +) -> Vec> { + let size = |b: u32| u64::from(profile.block(b).serialized_size); + let measured = profile.has_touch_graph(); + let mut children: Vec> = Vec::new(); + let mut cur: Vec = Vec::new(); + let mut cur_cost = AiurShardCost::default(); + let mut charged: FxHashSet = FxHashSet::default(); + let mut walked: FxHashSet = FxHashSet::default(); + let predicted = |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.hb); + + let union_delta = |b: u32, + charged: &mut FxHashSet, + walked: &mut FxHashSet| + -> u64 { + let mut bytes = 0u64; + let charge = |x: u32, charged: &mut FxHashSet, bytes: &mut u64| { + if charged.insert(x) { + *bytes = bytes.saturating_add(size(x)); + } + }; + if measured { + charge(b, charged, &mut bytes); + for &t in profile.touched_blocks(b) { + charge(t, charged, &mut bytes); + } + } else if walked.insert(b) { + let mut stack = vec![b]; + while let Some(x) = stack.pop() { + charge(x, charged, &mut bytes); + for &r in profile.refs(x) { + if walked.insert(r) { + stack.push(r); + } + } + } + } + bytes + }; + + for &b in blocks_in_order { + let e = profile.block(b); + let delta = union_delta(b, &mut charged, &mut walked); + let tentative = AiurShardCost { + union_bytes: cur_cost.union_bytes.saturating_add(delta), + hb: cur_cost.hb.saturating_add(e.heartbeats), + ..cur_cost + }; + if !cur.is_empty() && predicted(&tentative) > cap_gib { + children.push(std::mem::take(&mut cur)); + charged.clear(); + walked.clear(); + cur_cost = AiurShardCost::default(); + cur_cost.union_bytes = union_delta(b, &mut charged, &mut walked); + } else { + cur_cost.union_bytes = tentative.union_bytes; + } + cur_cost.hb = cur_cost.hb.saturating_add(e.heartbeats); + cur_cost.subst = cur_cost.subst.saturating_add(e.subst); + cur.push(b); + } + if !cur.is_empty() { + children.push(cur); + } + children +} + +/// Surgically re-partition ONE shard of an existing Aiur manifest at a +/// smaller per-shard RAM budget — the recourse when the cost model's blind +/// spot packs an outlier shard past what the box can prove. Every other +/// shard's block list is reproduced VERBATIM (asserted), so its claim digest +/// — and any cached proof keyed on it in `~/.ix/cache/shard-proofs/` — stays +/// valid; only shard `k` is replaced by its children. The first child keeps +/// id `k`, the rest are appended, and the aggregation tree's leaf `k` +/// becomes a left-leaning chain over the children. +pub fn rebudget_manifest_shard( + esp_path: &str, + manifest_path: &str, + shard_k: usize, + child_budget_gib: f64, + epsilon: f64, + out_path: &str, +) -> Result { + let bytes = + std::fs::read(esp_path).map_err(|e| format!("read {esp_path}: {e}"))?; + let profile = BlockProfile::from_bytes(&bytes) + .map_err(|e| format!("parse {esp_path}: {e}"))?; + if !profile.has_touch_graph() && !profile.has_ref_graph() { + return Err(format!( + "{esp_path} has neither a touch graph nor a reference graph — \ + rebudget needs the faulted-set accounting; regenerate with the \ + current `ix profile`" + )); + } + let mbytes = std::fs::read(manifest_path) + .map_err(|e| format!("read {manifest_path}: {e}"))?; + let manifest = ShardManifest::from_bytes(&mbytes) + .map_err(|e| format!("parse {manifest_path}: {e}"))?; + let old_n = manifest.shards.len(); + let parent = manifest + .shards + .get(shard_k) + .ok_or_else(|| format!("shard {shard_k} out of range (0..{old_n})"))?; + + let id_of: FxHashMap<&Address, u32> = profile + .blocks() + .iter() + .enumerate() + .map(|(i, b)| (&b.addr, i as u32)) + .collect(); + let to_id = |a: &Address| -> Result { + id_of + .get(a) + .copied() + .ok_or_else(|| format!("manifest block {a:?} not in profile")) + }; + let parent_blocks: FxHashSet = + parent.blocks.iter().map(&to_id).collect::>()?; + + // Pack the parent's blocks at the child budget, in the same cut-coherent + // global order the original partition used. + let cap_gib = child_budget_gib * AIUR_RAM_USABLE_FRAC; + let total_bytes: u64 = profile + .blocks() + .iter() + .fold(0u64, |a, b| a.saturating_add(u64::from(b.serialized_size))); + let total_hb: u64 = + profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.heartbeats)); + let total_ram = aiur_ram_gib(total_bytes, total_hb) - AIUR_RAM_BASE_GIB; + let headroom = (cap_gib - AIUR_RAM_BASE_GIB).max(f64::MIN_POSITIVE); + #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] + let pieces = (total_ram / headroom * PACK_PIECES_PER_CAP as f64) as usize; + let order = cut_coherent_order(&profile, pieces, epsilon); + let subset: Vec = + order.iter().copied().filter(|b| parent_blocks.contains(b)).collect(); + let children_ids = pack_block_subset_to_cap(&profile, &subset, cap_gib); + let n_children = children_ids.len(); + if n_children <= 1 { + return Err(format!( + "shard {shard_k} does not split at budget {child_budget_gib} GiB \ + (cap {cap_gib:.1}): got {n_children} child(ren) — lower the budget" + )); + } + + // Modified assignment: child 0 keeps id `shard_k`; the rest append. + let mut shard_of: Vec = vec![0; profile.num_blocks()]; + for (s, info) in manifest.shards.iter().enumerate() { + if s == shard_k { + continue; + } + for a in &info.blocks { + shard_of[to_id(a)? as usize] = s as u32; + } + } + let new_n = old_n + n_children - 1; + for (c, ids) in children_ids.iter().enumerate() { + let sid = if c == 0 { shard_k as u32 } else { (old_n + c - 1) as u32 }; + for &b in ids { + shard_of[b as usize] = sid; + } + } + + // `ShardManifest::build` is deterministic in (profile, shard_of), so the + // untouched shards reproduce byte-identically — asserted below, because + // that identity is exactly what keeps their claim digests (and cached + // proofs) valid. + let mut rebuilt = ShardManifest::build(&profile, &shard_of, new_n); + for shard in &mut rebuilt.shards { + shard.assumption_root = + ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); + } + for s in 0..old_n { + if s == shard_k { + continue; + } + if rebuilt.shards[s].blocks != manifest.shards[s].blocks { + return Err(format!( + "rebudget internal error: shard {s}'s block list changed — refusing \ + to write a manifest that would invalidate its cached proof" + )); + } + } + // Patch the aggregation tree: the parent's leaf becomes a left-leaning + // chain over its children, keeping every other leaf untouched. + fn patch_tree(node: &AggNode, k: u32, extra: &[u32]) -> AggNode { + match node { + AggNode::Leaf(id) if *id == k => { + let mut t = AggNode::Leaf(k); + for &e in extra { + t = AggNode::Internal(Box::new(t), Box::new(AggNode::Leaf(e))); + } + t + }, + AggNode::Leaf(id) => AggNode::Leaf(*id), + AggNode::Internal(l, r) => AggNode::Internal( + Box::new(patch_tree(l, k, extra)), + Box::new(patch_tree(r, k, extra)), + ), + } + } + let extra_ids: Vec = + (0..n_children - 1).map(|i| (old_n + i) as u32).collect(); + rebuilt.tree = + manifest.tree.as_ref().map(|t| patch_tree(t, shard_k as u32, &extra_ids)); + std::fs::write(out_path, rebuilt.to_bytes()) + .map_err(|e| format!("write {out_path}: {e}"))?; + + // Costs sidecar: recompute every row's faulted-set union from the profile + // (identical to the input rows for untouched shards — the union is a + // function of the owned set alone). + let measured = profile.has_touch_graph(); + let mut csv = String::from( + "shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,\ + pred_ram_gib,pred_prove_s\n", + ); + let mut report = String::new(); + let mut union_set: FxHashSet = FxHashSet::default(); + for (i, sh) in rebuilt.shards.iter().enumerate() { + let ids: Vec = + sh.blocks.iter().map(&to_id).collect::>()?; + union_set.clear(); + for &b in &ids { + union_set.insert(b); + if measured { + union_set.extend(profile.touched_blocks(b).iter().copied()); + } else { + let mut stack = vec![b]; + while let Some(x) = stack.pop() { + for &r in profile.refs(x) { + if union_set.insert(r) { + stack.push(r); + } + } + } + } + } + let union_bytes: u64 = union_set + .iter() + .map(|&b| u64::from(profile.block(b).serialized_size)) + .sum(); + let sum = |f: &dyn Fn(u32) -> u64| ids.iter().map(|&b| f(b)).sum::(); + let hb = sh.heartbeats; + let subst = sum(&|b| profile.block(b).subst); + let subst_unique = sum(&|b| profile.block(b).subst_unique); + let whnf = sum(&|b| profile.block(b).whnf); + let def_eq = sum(&|b| profile.block(b).def_eq); + let nat_arith = sum(&|b| profile.block(b).nat_arith); + let ram = aiur_ram_gib(union_bytes, hb); + csv.push_str(&format!( + "{},{},{},{},{},{},{},{},{:.2},{:.2}\n", + i, + union_bytes, + hb, + subst, + subst_unique, + whnf, + def_eq, + nat_arith, + ram, + aiur_prove_secs(union_bytes, subst), + )); + if i == shard_k || i >= old_n { + report.push_str(&format!( + " child shard {i}: {} blocks, union {:.1} MB, pred_ram {ram:.2} GiB\n", + sh.blocks.len(), + union_bytes as f64 / 1e6, + )); + } + } + let cp = format!("{out_path}.costs.csv"); + std::fs::write(&cp, csv).map_err(|e| format!("write {cp}: {e}"))?; + + Ok(format!( + "rebudget shard {shard_k} @ {child_budget_gib} GiB (cap {cap_gib:.1}): \ + {old_n} → {new_n} shards; all other shards copied verbatim\n{report}" + )) +} + /// Calibrated Zisk guest-COST model — the **single source of truth** for /// predicting a block's in-circuit cost contribution, in **ziskemu cost /// units** (`ziskemu -X` TOTAL: MAIN + OPCODES + MEMORY + PRECOMPILES + @@ -2392,10 +2677,10 @@ pub fn partition_for_aiur_ram( // Byte delta of adding `b`'s faulted set to the current shard's union. let union_delta = |b: u32, - shard_epoch: u32, - stack: &mut Vec, - charged_mark: &mut [u32], - walk_mark: &mut [u32]| + shard_epoch: u32, + stack: &mut Vec, + charged_mark: &mut [u32], + walk_mark: &mut [u32]| -> u64 { let mut bytes = 0u64; let charge = |x: u32, charged_mark: &mut [u32], bytes: &mut u64| { @@ -2931,6 +3216,76 @@ mod tests { assert_eq!(p, q); } + #[test] + fn rebudget_splits_one_shard_and_copies_the_rest_verbatim() { + // Six-block env, two natural clusters; pack everything into few shards + // at a large budget, then rebudget one shard at a small one. The other + // shards' block lists must be byte-identical (that identity is what + // keeps their cached proofs valid), and the new manifest must cover + // the same blocks with the split shard's children appended. + let mut b = ProfileBuilder::new(); + for i in 1..=6u8 { + b.block(addr(i), 2_000, 100_000, 1, ops(0)); + } + let p = + with_refs(b.finish(), &[vec![], vec![], vec![], vec![], vec![], vec![]]); + let dir = std::env::temp_dir(); + let pid = std::process::id(); + let prof = dir.join(format!("ix_rebudget_{pid}.ixprof")); + let m0 = dir.join(format!("ix_rebudget_{pid}.ixes")); + let m1 = dir.join(format!("ix_rebudget_{pid}_split.ixes")); + std::fs::write(&prof, p.to_bytes()).unwrap(); + // Budget picked so the 6 blocks pack into 2-3 shards. + shard_esp_aiur( + prof.to_str().unwrap(), + 20.0, + 0.05, + 1, + Some(m0.to_str().unwrap()), + ) + .unwrap(); + let before = + ShardManifest::from_bytes(&std::fs::read(&m0).unwrap()).unwrap(); + assert!(before.shards.len() >= 2, "fixture must pack multiple shards"); + // Split shard 0 at a smaller budget so it must break into children. + let report = rebudget_manifest_shard( + prof.to_str().unwrap(), + m0.to_str().unwrap(), + 0, + 12.0, + 0.05, + m1.to_str().unwrap(), + ) + .unwrap(); + let after = + ShardManifest::from_bytes(&std::fs::read(&m1).unwrap()).unwrap(); + assert!(after.shards.len() > before.shards.len(), "report: {report}"); + for s in 1..before.shards.len() { + assert_eq!( + after.shards[s].blocks, before.shards[s].blocks, + "untouched shard {s} must be copied verbatim" + ); + } + // Cover preserved: same multiset of owned blocks overall. + let owned = |m: &ShardManifest| { + let mut v: Vec
= + m.shards.iter().flat_map(|s| s.blocks.iter().cloned()).collect(); + v.sort(); + v + }; + assert_eq!(owned(&before), owned(&after)); + // Sidecar exists with one row per shard. + let csv = + std::fs::read_to_string(format!("{}.costs.csv", m1.to_str().unwrap())) + .unwrap(); + assert_eq!(csv.lines().count(), after.shards.len() + 1); + for f in [&prof, &m0, &m1] { + let _ = std::fs::remove_file(f); + } + let _ = std::fs::remove_file(format!("{}.costs.csv", m0.to_str().unwrap())); + let _ = std::fs::remove_file(format!("{}.costs.csv", m1.to_str().unwrap())); + } + #[test] fn shard_esp_file_roundtrip() { // Exercise the CLI's shard path: write a .ixprof, run shard_esp, read back From 9427ae7532a8f3bf3284cad62e80115426fb9b53 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Mon, 3 Aug 2026 17:17:27 +0000 Subject: [PATCH 05/20] shard: recalibrate the Aiur cost model as a two-stage counters->FFT->resources fit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replaces the placeholder coefficients (fit on the pre-addr-first eager kernel) with a model fit entirely on this kernel, restructured around the prover's actual work unit. Stage 1 predicts a run's total FFT cost from profile features: fft = 2.599e9 + 188.6*nlogn(faulted_bytes) + 71.27*nlogn(subst) + 6548*nlogn(def_eq) def_eq is load-bearing: it appears in every acceptable-tail fit, pricing the definitional-equality-dense shards that under the old model measured up to 25% over predicted RAM (reproduced on this kernel before the refit: the nat-heaviest Init shard proved at 219 GiB against a 175 prediction). nat_arith adds no explanatory power at shard scale on this corpus and stays a persisted-but-unmodeled feature; the exact path below covers its tail. Stage 2 maps FFT cost linearly to resources — physically grounded (committed LDE volume is proportional to FFT work): prove_secs = 6.18 + 2.0425 * BFFT RSS_gib = 13.59 + 2.3507 * BFFT exposed both composed (plan-time, from features) and as *_for_fft accessors, so a measured FFT cost from an execute-mode stats dump gives an exact-height prediction — the cheap pre-prove gate for any residual outlier, which can then be `--rebudget` before burning a prove. Corpus and fit quality (2026-08-03, this box): - stage 1: exact FFT of all 34 Init shards at a 250 GiB pack (execute stats dumps). MAPE 5.0%, worst under -18.5%. - stage 2: 13 measured Init shard proves spanning 21-81 BFFT. RSS max|err| 9.9%, wall 12.2%. Composed end-to-end on the proved set: RAM within 12.4%. - generalization: 60 InitStd shards the fit never saw. Stage-1 MAPE 5.7%, worst under -15.9% — inside the tail bound. - execute models refit on the same sweep (wall tracks def_eq alone, MAPE 9.6%; RSS bytes+def_eq, 3.7%). AIUR_RAM_USABLE_FRAC rises 0.70 -> 0.75: the composed worst-case under-prediction (stage-1 tail x stage-2 tail ~ -25%) inverts to 0.797, leaving the difference as OS/variance margin — headroom that is now derived from measurement instead of absorbing an unpriced blind spot. Validation, end to end: repacking Init at 250 GiB yields 32 shards (stale model: 34, one of which measured unprovable at a projected ~277 GiB); under the new pack no shard's exact-FFT-mapped RAM exceeds the budget, and the heaviest (88.2 BFFT) proved green at 227.2 GiB measured vs 220.9 mapped (+2.9%). Also fixed: both greedy pack loops' tentative cap-test cost accumulated only bytes+hb before testing — harmless when RAM ignored subst/def_eq, an under-test under any model with reduction terms. The ShardPipeline E2E now cuts its tiny env with the fixed-count min-cut partitioner: the composed model base (~19.7 GiB) exceeds anything a ~200-constant env can fill, so a RAM budget either degenerates to singletons or one shard; the claim layer is partition-agnostic and the RAM packer keeps its own unit coverage. --- Tests/Ix/Kernel/ShardPipeline.lean | 10 +- crates/ffi/src/kernel.rs | 12 +- crates/kernel/src/shard.rs | 224 ++++++++++++++++++----------- 3 files changed, 151 insertions(+), 95 deletions(-) diff --git a/Tests/Ix/Kernel/ShardPipeline.lean b/Tests/Ix/Kernel/ShardPipeline.lean index 3858b5a19..e2d21f783 100644 --- a/Tests/Ix/Kernel/ShardPipeline.lean +++ b/Tests/Ix/Kernel/ShardPipeline.lean @@ -59,11 +59,13 @@ def shardPipelineTests (env : Lean.Environment) let bytes ← IO.ofExcept (Ixon.serEnv ixonEnv) IO.FS.writeBinFile ixe bytes - -- .ixe → touch-graph profile → measured manifest. The tiny budget - -- forces a multi-shard partition so cross-shard frontiers exist. + -- .ixe → touch-graph profile → fixed 3-shard min-cut manifest. A fixed + -- count (not the Aiur RAM packer, whose composed base exceeds any budget + -- a ~200-constant env could fill) keeps the partition multi-shard and + -- small; the claim layer is partition-agnostic, and the RAM packer has + -- its own unit coverage. Ix.KernelCheck.rsProfileAnonFFI ixe.toString prof.toString true true "0" "aiur" - Ix.KernelCheck.rsShardEspCapFFI prof.toString "0" "6" "5" "1" - ixes.toString "aiur" + Ix.KernelCheck.rsShardEspFFI prof.toString "3" "10" "1" ixes.toString let (parsedEnv, shards) ← match ← Ix.Cli.CheckCmd.loadEnvAndShards ixes.toString ixe.toString with diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 5a55246ee..ce5a92eed 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -2512,10 +2512,10 @@ pub fn profile_sweep( whnf, def_eq, nat_arith: nat, - exec_s: aiur_exec_secs(bytes, subst), - exec_gib: aiur_exec_ram_gib(bytes), - prove_s: aiur_prove_secs(bytes, subst), - prove_gib: aiur_ram_gib(bytes, hb), + exec_s: aiur_exec_secs(def_eq), + exec_gib: aiur_exec_ram_gib(bytes, def_eq), + prove_s: aiur_prove_secs(bytes, subst, def_eq), + prove_gib: aiur_ram_gib(bytes, subst, def_eq), hot_mask, } }, @@ -2739,8 +2739,8 @@ fn print_profile_summary( if backend != ProfileBackend::Zisk { // Whole-env single-run prediction; large envs exceed any real box and // need `ix shard --backend aiur --max-ram G`. - let prove_s = aiur_prove_secs(ingress, subst); - let ram = aiur_ram_gib(ingress, hb); + let prove_s = aiur_prove_secs(ingress, subst, defeq); + let ram = aiur_ram_gib(ingress, subst, defeq); let warn = if ram > 250.0 { " → exceeds a 250 GiB box; shard it (ix shard --backend aiur --max-ram G)" } else { diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index 9b20df109..377172853 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -1688,7 +1688,7 @@ pub fn shard_esp_aiur( let prove_secs: Vec = plan .shard_costs .iter() - .map(|c| aiur_prove_secs(c.union_bytes, c.subst)) + .map(|c| aiur_prove_secs(c.union_bytes, c.subst, c.def_eq)) .collect(); if let Some(op) = out_path { let mut csv = String::from( @@ -1706,7 +1706,7 @@ pub fn shard_esp_aiur( c.whnf, c.def_eq, c.nat_arith, - aiur_ram_gib(c.union_bytes, c.hb), + aiur_ram_gib(c.union_bytes, c.subst, c.def_eq), prove_secs[i], )); } @@ -1757,7 +1757,8 @@ fn pack_block_subset_to_cap( let mut cur_cost = AiurShardCost::default(); let mut charged: FxHashSet = FxHashSet::default(); let mut walked: FxHashSet = FxHashSet::default(); - let predicted = |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.hb); + let predicted = + |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.subst, c.def_eq); let union_delta = |b: u32, charged: &mut FxHashSet, @@ -1791,9 +1792,13 @@ fn pack_block_subset_to_cap( for &b in blocks_in_order { let e = profile.block(b); let delta = union_delta(b, &mut charged, &mut walked); + // The tentative cost must carry every model feature, or the cap test + // under-predicts the candidate shard. let tentative = AiurShardCost { union_bytes: cur_cost.union_bytes.saturating_add(delta), hb: cur_cost.hb.saturating_add(e.heartbeats), + subst: cur_cost.subst.saturating_add(e.subst), + def_eq: cur_cost.def_eq.saturating_add(e.def_eq), ..cur_cost }; if !cur.is_empty() && predicted(&tentative) > cap_gib { @@ -1807,6 +1812,7 @@ fn pack_block_subset_to_cap( } cur_cost.hb = cur_cost.hb.saturating_add(e.heartbeats); cur_cost.subst = cur_cost.subst.saturating_add(e.subst); + cur_cost.def_eq = cur_cost.def_eq.saturating_add(e.def_eq); cur.push(b); } if !cur.is_empty() { @@ -1874,10 +1880,14 @@ pub fn rebudget_manifest_shard( .blocks() .iter() .fold(0u64, |a, b| a.saturating_add(u64::from(b.serialized_size))); - let total_hb: u64 = - profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.heartbeats)); - let total_ram = aiur_ram_gib(total_bytes, total_hb) - AIUR_RAM_BASE_GIB; - let headroom = (cap_gib - AIUR_RAM_BASE_GIB).max(f64::MIN_POSITIVE); + let total_subst: u64 = + profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.subst)); + let total_def_eq: u64 = + profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.def_eq)); + let base_ram = aiur_ram_gib(0, 0, 0); + let total_ram = + aiur_ram_gib(total_bytes, total_subst, total_def_eq) - base_ram; + let headroom = (cap_gib - base_ram).max(f64::MIN_POSITIVE); #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] let pieces = (total_ram / headroom * PACK_PIECES_PER_CAP as f64) as usize; let order = cut_coherent_order(&profile, pieces, epsilon); @@ -1995,7 +2005,7 @@ pub fn rebudget_manifest_shard( let whnf = sum(&|b| profile.block(b).whnf); let def_eq = sum(&|b| profile.block(b).def_eq); let nat_arith = sum(&|b| profile.block(b).nat_arith); - let ram = aiur_ram_gib(union_bytes, hb); + let ram = aiur_ram_gib(union_bytes, subst, def_eq); csv.push_str(&format!( "{},{},{},{},{},{},{},{},{:.2},{:.2}\n", i, @@ -2007,7 +2017,7 @@ pub fn rebudget_manifest_shard( def_eq, nat_arith, ram, - aiur_prove_secs(union_bytes, subst), + aiur_prove_secs(union_bytes, subst, def_eq), )); if i == shard_k || i >= old_n { report.push_str(&format!( @@ -2151,76 +2161,104 @@ fn nlogn(x: u64) -> f64 { x * (x + 2.0).log2() } -/// Calibrated Aiur cost model — predicts a **run's** (one Aiur prove: a whole -/// closure or one shard) prove time and peak host RAM directly from the kernel -/// profile counters, no Aiur execution needed. Features are run-level -/// aggregates: `bytes` is every serialized byte the run's checks fault in -/// (owned blocks plus the measured touched set — under the lazy kernel only -/// faulted bytes cost ingress trace rows), `hb`/`subst` are the run's summed -/// reduction counters. Fit against measured `aiur-check-prove` bench-suite -/// runs (bencher.dev `ix` project) of the pre-addr-first eager-ingress -/// kernel; coefficients and fit quality live in the calibrating commit's -/// message. Known limit: constants whose Aiur cost is dominated by big-Nat -/// limb gadgets have no native-counter signal and under-predict; -/// [`AIUR_RAM_USABLE_FRAC`] carries that risk. -pub const AIUR_PROVE_BASE_SECS: f64 = 1.43; -pub const AIUR_PROVE_SECS_PER_NLOGN_INGRESS_BYTE: f64 = 2.38e-7; -pub const AIUR_PROVE_SECS_PER_NLOGN_SUBST: f64 = 9.06e-7; -pub const AIUR_RAM_BASE_GIB: f64 = 3.67; -pub const AIUR_RAM_GIB_PER_NLOGN_INGRESS_BYTE: f64 = 1.18e-6; -pub const AIUR_RAM_GIB_PER_NLOGN_HEARTBEAT: f64 = 1.57e-5; -/// Usable fraction of an Aiur host-RAM budget. Lower than the Zisk -/// [`RAM_USABLE_FRAC`]: it also absorbs the model's blind spot on -/// limb-arithmetic-heavy blocks, not just OS overhead and variance. -pub const AIUR_RAM_USABLE_FRAC: f64 = 0.7; - -/// Predicted Aiur prove time (seconds) for one run faulting in `bytes` and -/// performing `subst` substitution-node visits. -pub fn aiur_prove_secs(bytes: u64, subst: u64) -> f64 { - AIUR_PROVE_BASE_SECS - + AIUR_PROVE_SECS_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) - + AIUR_PROVE_SECS_PER_NLOGN_SUBST * nlogn(subst) -} - -/// Predicted Aiur peak host RAM (GiB) for one run faulting in `bytes` at `hb` -/// heartbeats of reduction. -pub fn aiur_ram_gib(bytes: u64, hb: u64) -> f64 { - AIUR_RAM_BASE_GIB - + AIUR_RAM_GIB_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) - + AIUR_RAM_GIB_PER_NLOGN_HEARTBEAT * nlogn(hb) +/// Calibrated two-stage Aiur cost model. +/// +/// **Stage 1** predicts a run's total FFT cost (the prover's actual work +/// unit: `Σ width·2^⌈log h⌉·log h` over circuits) from the profile +/// counters of the run's owned blocks plus its faulted-set bytes. `def_eq` +/// is a load-bearing feature: definitional-equality-dense checks drive +/// trace volume that bytes/subst alone under-predict. +/// +/// **Stage 2** maps FFT cost linearly to prove wall seconds and peak host +/// RAM — physically grounded (committed LDE volume is proportional to FFT +/// work) and measured tight (≤10% on RAM, ≤12% on wall). +/// +/// Fit 2026-08-03 on this kernel (addr-first, lazy fault-in): stage 1 +/// against the exact per-shard FFT costs of all 34 Init shards at a 250 +/// GiB pack (execute-mode stats dumps; MAPE 5.0%, worst under −18.5%), +/// stage 2 against 13 measured shard proves spanning 21–81 BFFT (RSS +/// max |err| 9.9%, wall 12.2%). Composed end-to-end on the proved set: +/// RAM within 12.4%. The prove base term includes env load + system +/// setup, matching what the batch driver schedules. +pub const AIUR_FFT_BASE: f64 = 2.599e9; +pub const AIUR_FFT_PER_NLOGN_INGRESS_BYTE: f64 = 188.6; +pub const AIUR_FFT_PER_NLOGN_SUBST: f64 = 71.27; +pub const AIUR_FFT_PER_NLOGN_DEF_EQ: f64 = 6548.0; +pub const AIUR_PROVE_BASE_SECS: f64 = 6.18; +pub const AIUR_PROVE_SECS_PER_BFFT: f64 = 2.0425; +pub const AIUR_RAM_BASE_GIB: f64 = 13.59; +pub const AIUR_RAM_GIB_PER_BFFT: f64 = 2.3507; +/// Usable fraction of an Aiur host-RAM budget. Covers the composed model's +/// measured worst under-prediction (stage-1 tail −18.5% × stage-2 −8.5% ≈ +/// −25%, so predictions at cap stay under budget), with the remainder as +/// OS/variance margin. +pub const AIUR_RAM_USABLE_FRAC: f64 = 0.75; + +/// Stage 1: predicted total FFT cost for one run faulting in `bytes`, +/// with `subst` substitution-node visits and `def_eq` definitional +/// equality checks over its owned blocks. +pub fn aiur_shard_fft(bytes: u64, subst: u64, def_eq: u64) -> f64 { + AIUR_FFT_BASE + + AIUR_FFT_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) + + AIUR_FFT_PER_NLOGN_SUBST * nlogn(subst) + + AIUR_FFT_PER_NLOGN_DEF_EQ * nlogn(def_eq) +} + +/// Stage 2: prove wall seconds for a run of `fft` total FFT cost. Feed a +/// measured FFT cost (an execute-mode stats dump) for an exact-height +/// prediction, or [`aiur_shard_fft`]'s estimate at plan time. +pub fn aiur_prove_secs_for_fft(fft: f64) -> f64 { + AIUR_PROVE_BASE_SECS + AIUR_PROVE_SECS_PER_BFFT * (fft / 1e9) +} + +/// Stage 2: peak prover host RAM (GiB) for a run of `fft` total FFT cost. +pub fn aiur_ram_gib_for_fft(fft: f64) -> f64 { + AIUR_RAM_BASE_GIB + AIUR_RAM_GIB_PER_BFFT * (fft / 1e9) +} + +/// Composed plan-time prediction: prove wall seconds from profile features. +pub fn aiur_prove_secs(bytes: u64, subst: u64, def_eq: u64) -> f64 { + aiur_prove_secs_for_fft(aiur_shard_fft(bytes, subst, def_eq)) +} + +/// Composed plan-time prediction: peak prover host RAM (GiB) from profile +/// features. +pub fn aiur_ram_gib(bytes: u64, subst: u64, def_eq: u64) -> f64 { + aiur_ram_gib_for_fft(aiur_shard_fft(bytes, subst, def_eq)) } /// A block's marginal predicted Aiur prove time (seconds), `nlogn` taken at -/// block granularity and the per-run base omitted. Slightly under-counts a +/// block granularity and the per-run bases omitted. Slightly under-counts a /// block's share inside a large run (whose `log` factor is bigger), which is /// fine for its purpose: ranking blocks in the `ix profile` leaderboards. pub fn aiur_block_prove_secs(b: &BlockEntry) -> f64 { - AIUR_PROVE_SECS_PER_NLOGN_INGRESS_BYTE * nlogn(u64::from(b.serialized_size)) - + AIUR_PROVE_SECS_PER_NLOGN_SUBST * nlogn(b.subst) + let fft = AIUR_FFT_PER_NLOGN_INGRESS_BYTE + * nlogn(u64::from(b.serialized_size)) + + AIUR_FFT_PER_NLOGN_SUBST * nlogn(b.subst) + + AIUR_FFT_PER_NLOGN_DEF_EQ * nlogn(b.def_eq); + AIUR_PROVE_SECS_PER_BFFT * (fft / 1e9) } /// Calibrated Aiur **execute** (witness-generation, no prove) cost model — -/// same feature form and calibration pipeline as the prove model above, fit -/// against the `aiur-check-execute` bench suite. Execute RAM is bytes-only: -/// the retained query record is dominated by ingress/hashing rows, and no -/// second feature survives a non-negative fit. -pub const AIUR_EXEC_BASE_SECS: f64 = 0.146; -pub const AIUR_EXEC_SECS_PER_NLOGN_INGRESS_BYTE: f64 = 8.54e-8; -pub const AIUR_EXEC_SECS_PER_NLOGN_SUBST: f64 = 6.77e-8; -pub const AIUR_EXEC_RAM_BASE_GIB: f64 = 4.72; -pub const AIUR_EXEC_RAM_GIB_PER_NLOGN_INGRESS_BYTE: f64 = 8.50e-8; +/// fit on the same 34-shard Init sweep as stage 1 (wall MAPE 9.6%, RSS +/// 3.7%). Execute wall tracks `def_eq` alone; execute RSS adds the +/// faulted-byte term. +pub const AIUR_EXEC_BASE_SECS: f64 = 3.72; +pub const AIUR_EXEC_SECS_PER_NLOGN_DEF_EQ: f64 = 3.602e-6; +pub const AIUR_EXEC_RAM_BASE_GIB: f64 = 1.34; +pub const AIUR_EXEC_RAM_GIB_PER_NLOGN_INGRESS_BYTE: f64 = 3.008e-8; +pub const AIUR_EXEC_RAM_GIB_PER_NLOGN_DEF_EQ: f64 = 6.119e-7; /// Predicted Aiur execute time (seconds) for one run. -pub fn aiur_exec_secs(bytes: u64, subst: u64) -> f64 { - AIUR_EXEC_BASE_SECS - + AIUR_EXEC_SECS_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) - + AIUR_EXEC_SECS_PER_NLOGN_SUBST * nlogn(subst) +pub fn aiur_exec_secs(def_eq: u64) -> f64 { + AIUR_EXEC_BASE_SECS + AIUR_EXEC_SECS_PER_NLOGN_DEF_EQ * nlogn(def_eq) } /// Predicted Aiur execute peak host RAM (GiB) for one run. -pub fn aiur_exec_ram_gib(bytes: u64) -> f64 { +pub fn aiur_exec_ram_gib(bytes: u64, def_eq: u64) -> f64 { AIUR_EXEC_RAM_BASE_GIB + AIUR_EXEC_RAM_GIB_PER_NLOGN_INGRESS_BYTE * nlogn(bytes) + + AIUR_EXEC_RAM_GIB_PER_NLOGN_DEF_EQ * nlogn(def_eq) } /// Whole-workload prove-time estimate over a partition's per-shard step counts. @@ -2590,7 +2628,7 @@ pub fn partition_for_aiur_ram( tree: AggNode::Leaf(0), ram_cap_gib, shard_costs: Vec::new(), - max_shard_ram_gib: AIUR_RAM_BASE_GIB, + max_shard_ram_gib: aiur_ram_gib(0, 0, 0), largest_block_ram_gib: 0.0, infeasible_atomic_floor: false, }; @@ -2637,7 +2675,11 @@ pub fn partition_for_aiur_ram( .collect() }; let lone_block_ram = |b: u32| { - aiur_ram_gib(closure_bytes[b as usize], profile.block(b).heartbeats) + aiur_ram_gib( + closure_bytes[b as usize], + profile.block(b).subst, + profile.block(b).def_eq, + ) }; let largest_block_ram_gib = (0..nblocks as u32).map(lone_block_ram).fold(0.0, f64::max); @@ -2650,10 +2692,14 @@ pub fn partition_for_aiur_ram( .blocks() .iter() .fold(0u64, |a, b| a.saturating_add(u64::from(b.serialized_size))); - let total_hb: u64 = - profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.heartbeats)); - let total_ram = aiur_ram_gib(total_bytes, total_hb) - AIUR_RAM_BASE_GIB; - let headroom = (ram_cap_gib - AIUR_RAM_BASE_GIB).max(f64::MIN_POSITIVE); + let total_subst: u64 = + profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.subst)); + let total_def_eq: u64 = + profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.def_eq)); + let base_ram = aiur_ram_gib(0, 0, 0); + let total_ram = + aiur_ram_gib(total_bytes, total_subst, total_def_eq) - base_ram; + let headroom = (ram_cap_gib - base_ram).max(f64::MIN_POSITIVE); #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] let pieces = (total_ram / headroom * PACK_PIECES_PER_CAP as f64) as usize; let order = cut_coherent_order(profile, pieces, epsilon); @@ -2673,7 +2719,8 @@ pub fn partition_for_aiur_ram( let mut cur = 0u32; let mut owned_in_cur = 0usize; let mut infeasible = false; - let predicted = |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.hb); + let predicted = + |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.subst, c.def_eq); // Byte delta of adding `b`'s faulted set to the current shard's union. let union_delta = |b: u32, @@ -2724,9 +2771,13 @@ pub fn partition_for_aiur_ram( &mut charged_mark, &mut walk_mark, ); + // The tentative cost must carry every model feature, or the cap test + // under-predicts the candidate shard. let tentative = AiurShardCost { union_bytes: cur_cost.union_bytes.saturating_add(delta), hb: cur_cost.hb.saturating_add(e.heartbeats), + subst: cur_cost.subst.saturating_add(e.subst), + def_eq: cur_cost.def_eq.saturating_add(e.def_eq), ..cur_cost }; @@ -3068,13 +3119,15 @@ mod tests { #[test] fn aiur_model_monotone() { // The packer's greedy cap test is only sound if the model never decreases - // when a shard grows in either aggregate. - let base = aiur_ram_gib(1_000_000, 10_000); - assert!(aiur_ram_gib(2_000_000, 10_000) > base); - assert!(aiur_ram_gib(1_000_000, 20_000) > base); - let p = aiur_prove_secs(1_000_000, 100_000); - assert!(aiur_prove_secs(2_000_000, 100_000) > p); - assert!(aiur_prove_secs(1_000_000, 200_000) > p); + // when a shard grows in any aggregate. + let base = aiur_ram_gib(1_000_000, 10_000, 10_000); + assert!(aiur_ram_gib(2_000_000, 10_000, 10_000) > base); + assert!(aiur_ram_gib(1_000_000, 20_000, 10_000) > base); + assert!(aiur_ram_gib(1_000_000, 10_000, 20_000) > base); + let p = aiur_prove_secs(1_000_000, 100_000, 10_000); + assert!(aiur_prove_secs(2_000_000, 100_000, 10_000) > p); + assert!(aiur_prove_secs(1_000_000, 200_000, 10_000) > p); + assert!(aiur_prove_secs(1_000_000, 100_000, 20_000) > p); } /// Attach a reference graph given per-block (sorted, deduped) ref lists. @@ -3091,7 +3144,7 @@ mod tests { // downstream of its first member. let mut b = ProfileBuilder::new(); for i in 1..=40u8 { - b.block(addr(i), 10_000, 20_000, 1, ops(100_000)); + b.block(addr(i), 10_000, 20_000, 1, ops(5_000_000)); } for i in 1..40u8 { b.delta_edge(addr(i), addr(i + 1)); @@ -3148,11 +3201,11 @@ mod tests { }; let fallback = partition_for_aiur_ram(&build(false), 1000.0, 0.05); assert!( - (fallback.largest_block_ram_gib - aiur_ram_gib(4000, 10)).abs() < 1e-9 + (fallback.largest_block_ram_gib - aiur_ram_gib(4000, 0, 0)).abs() < 1e-9 ); let measured = partition_for_aiur_ram(&build(true), 1000.0, 0.05); assert!( - (measured.largest_block_ram_gib - aiur_ram_gib(2000, 10)).abs() < 1e-9 + (measured.largest_block_ram_gib - aiur_ram_gib(2000, 0, 0)).abs() < 1e-9 ); } @@ -3180,7 +3233,7 @@ mod tests { b.block(addr(2), 10, 3_000_000, 1, ops(0)); let p = with_refs(b.finish(), &[vec![1], vec![]]); let plan = partition_for_aiur_ram(&p, 1000.0, 0.05); - let floor = aiur_ram_gib(3_000_100, 10); + let floor = aiur_ram_gib(3_000_100, 0, 0); assert!( (plan.largest_block_ram_gib - floor).abs() < 1e-9, "floor {} != closure-based {}", @@ -3225,7 +3278,7 @@ mod tests { // the same blocks with the split shard's children appended. let mut b = ProfileBuilder::new(); for i in 1..=6u8 { - b.block(addr(i), 2_000, 100_000, 1, ops(0)); + b.block(addr(i), 2_000, 1_000, 1, ops(5_000_000)); } let p = with_refs(b.finish(), &[vec![], vec![], vec![], vec![], vec![], vec![]]); @@ -3235,10 +3288,11 @@ mod tests { let m0 = dir.join(format!("ix_rebudget_{pid}.ixes")); let m1 = dir.join(format!("ix_rebudget_{pid}_split.ixes")); std::fs::write(&prof, p.to_bytes()).unwrap(); - // Budget picked so the 6 blocks pack into 2-3 shards. + // Budget picked so the 6 blocks pack into 2-3 shards (composed base + // ~19.7 GiB + ~18.6 GiB marginal per block at subst 5e6). shard_esp_aiur( prof.to_str().unwrap(), - 20.0, + 100.0, 0.05, 1, Some(m0.to_str().unwrap()), @@ -3252,7 +3306,7 @@ mod tests { prof.to_str().unwrap(), m0.to_str().unwrap(), 0, - 12.0, + 60.0, 0.05, m1.to_str().unwrap(), ) From 600ab7f50fe37853d75cda52314ab7c0514e73ed Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Tue, 4 Aug 2026 13:28:48 +0000 Subject: [PATCH 06/20] =?UTF-8?q?aiur:=20lazy=20witness=20fault-in=20?= =?UTF-8?q?=E2=80=94=20IOBuffer=20faults=20env=20bytes=20on=20demand?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The witness IOBuffer materialized a shard's full bfs_closure eagerly, 8x-expanded (one G per byte), before the kernel executed a single query — ~2.5 GiB per Init shard buffer, ~30 GiB at Mathlib scale, per in-flight shard. The kernel's laziness was circuit-side only: shipped- but-unfaulted bytes cost zero rows, but the host always paid for the whole closure. IOBuffer gains an optional IOFaultSource backing consulted on a get_info miss: EnvFaultSource resolves ch 2/3/4 keys against the shared mmap'd env and materializes entries on first fault, so host witness RAM scales with the FAULTED set — what the check actually touches — instead of the shipped closure. Soundness-neutral: faulted bytes are blake3-verified against their content-addressed key exactly like eagerly-seeded ones, and the idx/len wires are unconstrained witness either way. Trace generation reads through a frozen lookup (get_info_frozen): it runs circuits in parallel over a shared buffer and never needs to fault — execution already materialized every entry it read. EnvHandle holds Arc so a backing outlives any handle borrow. The claim-channel seeding (ch 0/1) is factored into seed_shard_check_env_claim, shared by the eager and lazy builders, and all four with-env check/prove FFI paths now use the lazy variants. --- crates/aiur/src/execute.rs | 97 +++++++++++-- crates/aiur/src/synthesis.rs | 3 +- crates/aiur/src/trace.rs | 4 +- crates/ffi/src/aiur/protocol.rs | 16 ++- crates/ixvm-codegen/src/aiur_ixvm_witness.rs | 129 +++++++++++++++--- .../src/aiur_multi_stark_runner.rs | 3 +- crates/ixvm-codegen/src/env_handle.rs | 11 +- 7 files changed, 212 insertions(+), 51 deletions(-) diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index d4284b9c4..98647e1b5 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -38,36 +38,107 @@ impl QueryRecord { } } +#[derive(Clone, Copy)] pub struct IOKeyInfo { pub idx: usize, pub len: usize, } +/// On-demand witness supplier for an [`IOBuffer`]: when execution asks for +/// a `(channel, key)` the buffer does not hold, the backing gets one chance +/// to produce the data, which is then materialized into the buffer exactly +/// as if the host had seeded it eagerly. Execution cannot observe the +/// difference — same bytes, same keys, same in-circuit verification — so +/// host witness RAM scales with the FAULTED set instead of the shipped +/// closure. `Send + Sync` because scan/check workers share one source. +pub trait IOFaultSource: Send + Sync { + fn fault(&self, channel: G, key: &[G]) -> Option>; +} + pub struct IOBuffer { /// Per-channel data arenas. `idx` slots into `data[&channel]`. pub data: FxHashMap>, /// Channel-keyed info map; same `key` on different channels resolves /// to distinct `IOKeyInfo`. pub map: FxHashMap<(G, Vec), IOKeyInfo>, + /// Lazy witness backing; `None` means fully host-seeded (the eager + /// builders and the Lean-marshalled buffers). + pub backing: Option>, +} + +impl Default for IOBuffer { + fn default() -> Self { + Self::new() + } } impl IOBuffer { + pub fn new() -> Self { + Self { + data: FxHashMap::default(), + map: FxHashMap::default(), + backing: None, + } + } + + pub fn with_backing(backing: std::sync::Arc) -> Self { + Self { + data: FxHashMap::default(), + map: FxHashMap::default(), + backing: Some(backing), + } + } + + fn invalid_key(channel: G, key: &[G]) -> ExecError { + // Name the channel and key: a missing witness entry is otherwise + // indistinguishable from any other, and the key identifies the + // constant or blob whose bytes the host failed to seed. + let hex: String = key + .iter() + .map(|g| format!("{:02x}", g.as_canonical_u64() & 0xff)) + .collect(); + ExecError::InvalidIOKey { channel: channel.as_canonical_u64(), key: hex } + } + + /// Execution-path lookup: on a miss, the `backing` (if any) may + /// materialize the entry into the buffer before the lookup fails. + /// `&mut` because a fault appends to the arena; both the interpreter + /// and the codegen'd kernels thread `&mut IOBuffer` already. #[inline] pub fn get_info( + &mut self, + channel: G, + key: &[G], + ) -> Result { + if let Some(info) = self.map.get(&(channel, key.to_vec())) { + return Ok(*info); + } + if let Some(src) = &self.backing + && let Some(data) = src.fault(channel, key) + { + let arena = self.data.entry(channel).or_default(); + let info = IOKeyInfo { idx: arena.len(), len: data.len() }; + arena.extend(data); + self.map.insert((channel, key.to_vec()), info); + return Ok(info); + } + Err(Self::invalid_key(channel, key)) + } + + /// Read-only lookup for post-execution passes (trace generation runs + /// circuits in parallel over a shared buffer): never faults — by trace + /// time execution has materialized every entry it read. + #[inline] + pub fn get_info_frozen( &self, channel: G, key: &[G], - ) -> Result<&IOKeyInfo, ExecError> { - self.map.get(&(channel, key.to_vec())).ok_or_else(|| { - // Name the channel and key: a missing witness entry is otherwise - // indistinguishable from any other, and the key identifies the - // constant or blob whose bytes the host failed to seed. - let hex: String = key - .iter() - .map(|g| format!("{:02x}", g.as_canonical_u64() & 0xff)) - .collect(); - ExecError::InvalidIOKey { channel: channel.as_canonical_u64(), key: hex } - }) + ) -> Result { + self + .map + .get(&(channel, key.to_vec())) + .copied() + .ok_or_else(|| Self::invalid_key(channel, key)) } fn set_info( &mut self, @@ -409,8 +480,8 @@ impl Function { let channel = map[*channel]; let key = key.iter().map(|v| map[*v]).collect::>(); let IOKeyInfo { idx, len } = io_buffer.get_info(channel, &key)?; - map.push(G::from_usize(*idx)); - map.push(G::from_usize(*len)); + map.push(G::from_usize(idx)); + map.push(G::from_usize(len)); }, ExecEntry::Op(Op::IOSetInfo(channel, key, idx, len)) => { let channel = map[*channel]; diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index cf5083b07..085fa6d6f 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -324,7 +324,6 @@ mod tests { p3_field::PrimeCharacteristicRing, types::{CommitmentParameters, FriParameters}, }; - use rustc_hash::FxHashMap; /// Small FRI parameters mirroring `vk_codec`'s test config: cheap to prove /// while still exercising the full FRI pipeline (log_blowup 1, 64 queries, @@ -342,7 +341,7 @@ mod tests { } fn empty_io_buffer() -> IOBuffer { - IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() } + IOBuffer::new() } /// Hand-build the toplevel for a single constrained function `f(a, b) = a*b`. diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index fe107ab10..7a2aec8f3 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -377,8 +377,8 @@ impl Op { let channel = map[*channel].0; let key = key.iter().map(|a| map[*a].0).collect::>(); let IOKeyInfo { idx, len } = - io_buffer.get_info(channel, &key).expect("Invalid IO key"); - for f in [G::from_usize(*idx), G::from_usize(*len)] { + io_buffer.get_info_frozen(channel, &key).expect("Invalid IO key"); + for f in [G::from_usize(idx), G::from_usize(len)] { map.push((f, 1)); slice.push_auxiliary(index, f); } diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 5e5417545..3c347e5e0 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -462,8 +462,9 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env( let env = &env_handle.get().env; let (_claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_claim_check_witness(env, &addr) - { + match ixvm_codegen::aiur_ixvm_witness::build_claim_check_witness_lazy( + env, &addr, + ) { Ok(t) => t, Err(e) => { return LeanExcept::error_string(&format!("witness build: {e}")); @@ -515,7 +516,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env( // shard entrypoint builds the the kernel witness (thin frontier + wrapper // augmentation). let (_claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( + match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness_lazy( env, &owned, ) { Ok(t) => t, @@ -566,8 +567,9 @@ extern "C" fn rs_aiur_system_prove_addr_with_env( let env = &env_handle.get().env; let (claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_claim_check_witness(env, &addr) - { + match ixvm_codegen::aiur_ixvm_witness::build_claim_check_witness_lazy( + env, &addr, + ) { Ok(t) => t, Err(e) => { return LeanExcept::error_string(&format!("witness build: {e}")); @@ -605,7 +607,7 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( let env = &env_handle.get().env; let (claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( + match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness_lazy( env, &owned, ) { Ok(t) => t, @@ -763,7 +765,7 @@ fn decode_io_buffer( ) -> IOBuffer { let data = decode_io_buffer_data(io_data_arr); let map = decode_io_buffer_map(io_map_arr); - IOBuffer { data, map } + IOBuffer { data, map, backing: None } } /// Build a Lean `Array (G × Array G)` enumerating the per-channel diff --git a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs index 062734da5..7548ae552 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs @@ -39,12 +39,14 @@ //! (extending channel arenas + inserting into the key→(idx,len) //! map) runs serially, since the arena `idx` is monotonic. -use multi_stark::p3_field::PrimeCharacteristicRing; +use std::sync::Arc; + +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use rayon::prelude::*; use rustc_hash::FxHashSet; use aiur::G; -use aiur::execute::{IOBuffer, IOKeyInfo}; +use aiur::execute::{IOBuffer, IOFaultSource, IOKeyInfo}; use ix_common::address::Address; use ix_common::env::ReducibilityHints; use ix_common::prim_addrs::PrimAddrs; @@ -52,6 +54,55 @@ use ixon::Env; use ixon::assumption_tree::AssumptionTree; use ixon::proof::Claim; +/// Lazy witness backing over a shared env: materializes ch 2 (constant +/// bytes), ch 3 (Defn hint), and ch 4 (blob bytes) entries on first +/// `io_read` miss instead of seeding the whole `bfs_closure` eagerly. +/// Host witness RAM then scales with the FAULTED set — what the check +/// actually touches — instead of the shipped closure, which the eager +/// path stores 8×-expanded (one `G` per byte). Soundness-neutral: the +/// kernel blake3-verifies faulted bytes against their content-addressed +/// key exactly as it does eagerly-seeded ones, and no scope widens — +/// content addressing means a key can only ever resolve to one value. +pub struct EnvFaultSource { + env: Arc, +} + +impl EnvFaultSource { + pub fn new(env: Arc) -> Arc { + Arc::new(Self { env }) + } +} + +/// Decode a 32-limb channel key back to the `Address` it spells; `None` +/// if any limb is out of byte range (such a key can name no env entry). +fn key_to_addr(key: &[G]) -> Option
{ + if key.len() != 32 { + return None; + } + let mut bytes = [0u8; 32]; + for (i, g) in key.iter().enumerate() { + let Ok(b) = u8::try_from(g.as_canonical_u64()) else { + return None; + }; + bytes[i] = b; + } + Address::from_slice(&bytes).ok() +} + +impl IOFaultSource for EnvFaultSource { + fn fault(&self, channel: G, key: &[G]) -> Option> { + let addr = key_to_addr(key)?; + match channel.as_canonical_u64() { + 2 => { + self.env.consts.get(&addr).map(|lc| bytes_to_g(lc.raw_bytes())) + }, + 3 => self.env.anon_hints.get(&addr).map(|h| vec![hint_to_g(&h)]), + 4 => self.env.blobs.get(&addr).map(|b| bytes_to_g(b.value())), + _ => None, + } + } +} + /// Append `data` to the per-channel arena and record `(idx, len)` /// in the `(channel, key)` info map. #[inline] @@ -203,10 +254,7 @@ pub fn build_claim_check_witness( let digest = Address::hash(&claim_bytes); let digest_key = addr_key(&digest); - let mut io = IOBuffer { - data: rustc_hash::FxHashMap::default(), - map: rustc_hash::FxHashMap::default(), - }; + let mut io = IOBuffer::new(); // ch 0: claim bytes extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); // ch 2/3/4: per-const/hint/blob entries — parallel byte conversion. @@ -279,19 +327,36 @@ pub fn build_shard_check_env_witness( env: &Env, owned: &[Address], ) -> Result<(Claim, Vec, IOBuffer), String> { - // Claim + THIN frontier from the shared convention module — the - // single source of truth for shard CheckEnv digests (see - // ixon::shard_claim; Lean mirror: - // IxVM.ClaimHarness.shardCheckEnvClaimThin). + let mut io = IOBuffer::new(); + let (claim, digest_key) = seed_shard_check_env_claim(env, owned, &mut io)?; + let byte_scope = witness_scope(env, owned); + add_entries_parallel(env, &byte_scope, &mut io); + Ok((claim, digest_key, io)) +} + +/// Seed ONLY the claim-side channels for a thin-frontier +/// `CheckEnv{owned}` claim into `io`: the claim wire (ch 0) and the +/// owned/assumption trees (ch 1). Byte channels (2/3/4) are the caller's +/// business — eagerly via `add_entries_parallel` or lazily via an +/// `EnvFaultSource` backing. Returns the claim and its digest key (the +/// `verify_claim` entry input). Claim + THIN frontier come from the +/// shared convention module — the single source of truth for shard +/// CheckEnv digests (see `ixon::shard_claim`; Lean mirror: +/// `IxVM.ClaimHarness.shardCheckEnvClaimThin`). +pub fn seed_shard_check_env_claim( + env: &Env, + owned: &[Address], + io: &mut IOBuffer, +) -> Result<(Claim, Vec), String> { let (claim, frontier) = ixon::shard_claim::shard_check_env_claim(env, owned) .ok_or_else(|| { - "build_shard_check_env_witness: empty owned set".to_string() + "seed_shard_check_env_claim: empty owned set".to_string() })?; let mut owned_sorted: Vec
= owned.to_vec(); owned_sorted.sort(); let owned_tree = AssumptionTree::canonical(&owned_sorted).ok_or_else(|| { - "build_shard_check_env_witness: empty owned set".to_string() + "seed_shard_check_env_claim: empty owned set".to_string() })?; let asm_tree = AssumptionTree::canonical(&frontier); debug_assert_eq!( @@ -305,24 +370,44 @@ pub fn build_shard_check_env_witness( claim.put(&mut claim_bytes); let digest = Address::hash(&claim_bytes); let digest_key = addr_key(&digest); - - let mut io = IOBuffer { - data: rustc_hash::FxHashMap::default(), - map: rustc_hash::FxHashMap::default(), - }; - extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); - let byte_scope = witness_scope(env, owned); - add_entries_parallel(env, &byte_scope, &mut io); + extend(io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); extend( - &mut io, + io, G::ONE, addr_key(&owned_tree.root()), bytes_to_g(&owned_tree.ser()), ); if let Some(at) = asm_tree { - extend(&mut io, G::ONE, addr_key(&at.root()), bytes_to_g(&at.ser())); + extend(io, G::ONE, addr_key(&at.root()), bytes_to_g(&at.ser())); } + Ok((claim, digest_key)) +} +/// Lazy-witness variant of [`build_shard_check_env_witness`]: claim +/// channels seeded eagerly, byte channels served on demand by an +/// [`EnvFaultSource`] over the shared env. Witness RAM ∝ faulted set. +pub fn build_shard_check_env_witness_lazy( + env: &Arc, + owned: &[Address], +) -> Result<(Claim, Vec, IOBuffer), String> { + let mut io = IOBuffer::with_backing(EnvFaultSource::new(env.clone())); + let (claim, digest_key) = seed_shard_check_env_claim(env, owned, &mut io)?; + Ok((claim, digest_key, io)) +} + +/// Lazy-witness variant of [`build_claim_check_witness`]: only the claim +/// wire is seeded; constant/hint/blob bytes fault in on demand. +pub fn build_claim_check_witness_lazy( + env: &Arc, + target: &Address, +) -> Result<(Claim, Vec, IOBuffer), String> { + let claim = Claim::Check { const_addr: target.clone(), assumptions: None }; + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let digest = Address::hash(&claim_bytes); + let digest_key = addr_key(&digest); + let mut io = IOBuffer::with_backing(EnvFaultSource::new(env.clone())); + extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); Ok((claim, digest_key, io)) } diff --git a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs index 720fce56f..5365e196b 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs @@ -17,7 +17,6 @@ //! buffer across FFI. use multi_stark::p3_field::PrimeCharacteristicRing; -use rustc_hash::FxHashMap; use crate::aiur_multi_stark::execute_generated; use aiur::G; @@ -60,7 +59,7 @@ pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer { let _ = std::fs::write(format!("{dir}/claims.bin"), claims); } let mut io = - IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() }; + IOBuffer::new(); for (channel, bytes) in [(0u64, proof), (1, vk), (2, claims)].map(|(c, b)| (G::from_u64(c), b)) { diff --git a/crates/ixvm-codegen/src/env_handle.rs b/crates/ixvm-codegen/src/env_handle.rs index 8a5168dce..fb0dd1e6b 100644 --- a/crates/ixvm-codegen/src/env_handle.rs +++ b/crates/ixvm-codegen/src/env_handle.rs @@ -11,17 +11,22 @@ //! `Env::anon_hints` map — both readers used here populate the map //! directly, so no post-decode harvest is needed. +use std::sync::Arc; + use ixon::Env; +/// The env is held behind an `Arc` so lazy witness backings +/// (`aiur_ixvm_witness::EnvFaultSource`) can hold a clone that outlives +/// any particular borrow of the handle. pub struct EnvHandle { - pub env: Env, + pub env: Arc, } impl EnvHandle { /// Load via `Env::get_anon_mmap` (zero-copy mmap of the `.ixe` file). pub fn from_ixe_path(path: &std::path::Path) -> Result { let env = Env::get_anon_mmap(path)?; - Ok(Self { env }) + Ok(Self { env: Arc::new(env) }) } /// Decode a serialized env blob (`Ixon.serEnv` output) via @@ -30,6 +35,6 @@ impl EnvHandle { pub fn from_bytes(bytes: &[u8]) -> Result { let mut cursor: &[u8] = bytes; let env = Env::get(&mut cursor)?; - Ok(Self { env }) + Ok(Self { env: Arc::new(env) }) } } From 1de5c727ea110186e2391166c367c743508e6b63 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Tue, 4 Aug 2026 23:41:04 +0000 Subject: [PATCH 07/20] shard scan: measured scan-and-cut sharding for Aiur MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Shard boundaries come from executing the env's check schedule through the codegen'd Aiur kernel — thin-frontier CheckEnv claims, the exact unit a prover pays for — with a running cost readout, replacing the counter-prediction path for Aiur. `ix shard env.ixe` runs the scan by default; `--backend zisk` chains profile + guest-cost pack; the .ixprof packer is unchanged for Zisk. - Two-term cut: a shard ends when RAM-per-fft * fft + record bytes reaches the budget's usable headroom — both resources a prove consumes. - One RAM mechanism: a per-worker record-byte cap ((0.70*box - 10)/workers, 8 GiB autoscale floor; --workers 1 grants the whole allowance), enforced inside execution via thread-local accounting in QueryMap::insert and codegen'd record_budget_exceeded() polls (ExecError::RecordBudgetExceeded). A trip mid-segment is an early cut; a block over the cap alone is skipped and named. Fleet RAM is workers x cap by construction — no reactive control. - True costs: every shard is re-priced with one cold CheckEnv — the claim its prove executes — and the merge pass consolidates on true costs to a fixpoint. - Manifest v2: tagged per-shard cost (Unknown / ProfileHeartbeats / ZiskCostUnits / AiurFft, raw fft units), version-checked in both the Rust and Lean parsers; ix prove orders heaviest-first from the manifest; the costs CSV sidecar is report-only. - Parallel scan over chunked schedule with work stealing; --fail-fast (default) / --no-fail-fast uniform across ix shard / check / prove, skipped blocks inventoried in failed.csv; IX_SCAN_LIMIT_BLOCKS slice knob for reproducers. - aiur-shard bench backend gains whole-env rows: scan-time, peak-rss, shards, max-shard-fft, and fft-cost in raw fft units so env totals join the existing per-constant plot. Validated at 250 GiB: Init 40 shards / 1,719 BFFT total (152 s, peak 91 GiB); InitStd 76 / 3,330 (255 s, 127 GiB); Lean 108 / 5,086 (383 s, 123 GiB); zero skipped blocks; deterministic partitions; prove spot check 74.8 GiB real vs 76.1 predicted. --- Ix/Aiur/Semantics/BytecodeFfi.lean | 18 + Ix/Aiur/Stages/Codegen.lean | 15 +- Ix/Cli/BenchCmd.lean | 152 +- Ix/Cli/CheckCmd.lean | 59 +- Ix/Cli/ProveCmd.lean | 40 +- Ix/Cli/ShardCmd.lean | 146 +- Tests/Ix/Kernel/ShardPipeline.lean | 24 + crates/aiur/src/execute.rs | 146 +- crates/aiur/src/querymap.rs | 1 + crates/ffi/src/aiur.rs | 1 + crates/ffi/src/aiur/scan.rs | 910 + crates/ffi/src/kernel.rs | 2 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 22714 ++++++++++-------- crates/ixvm-codegen/src/aiur_ixvm_runner.rs | 22 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 852 +- crates/kernel/src/shard.rs | 169 +- 16 files changed, 14704 insertions(+), 10567 deletions(-) create mode 100644 crates/ffi/src/aiur/scan.rs diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index fcd920e71..0fdc6a32d 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -211,6 +211,24 @@ def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel) (shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode).map fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) +/-- Scan-and-cut sharding: execute the env's check schedule through the + codegen'd kernel as incrementally-grown thin-frontier `CheckEnv` + claims — the same claim type the prover pays for — with a running + FFT-cost readout, cutting shard boundaries where the measured cost + reaches the RAM budget's FFT equivalent (see + `crates/ffi/src/aiur/scan.rs`). Witness bytes fault in lazily, so a + scanner's RAM tracks one segment's touched set. Writes the `.ixes` + manifest plus a `.costs.csv` sidecar carrying the MEASURED per-shard + FFT mapped through the calibrated resource lines. Numeric params are + decimal strings (ABI-simple): budget GiB, cut headroom percent, + parallel chunk scanners (0 = autoscale), fail-fast ("0" skips + kernel-rejected blocks, recording them in a `.failed.csv` sidecar; + anything else aborts on the first). -/ +@[extern "rs_aiur_scan_shards_with_env"] +opaque scanShardsWithEnv : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → @& String → + @& String → @& String → Except String Unit + end Bytecode.Toplevel end Aiur diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 5fdf8fde2..556e3ff6d 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -419,7 +419,9 @@ private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt := s!" result.output[0]" ++ s!" } else \{" ++ s!" let __ptr = G::from_usize(__mq.len());" ++ - s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }" + s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained));" ++ + s!" if record_budget_exceeded() \{ return Err(ExecError::RecordBudgetExceeded); }" ++ + s!" __ptr } }" #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] /-- `Op::Load`: mirror execute.rs lines 328-345. Look up by pointer @@ -802,8 +804,14 @@ partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String) #[.ref (.index (.var "inp") (.lit "..")), .ref (.index (.var "__ret") (.lit "..")), gFromBool (.lit "!unconstrained")]) + -- The budget poll rides the memoization insert — the unit of record + -- growth — so a bounded execution aborts within one unique query of + -- its limit. + let budgetCheck : RustStmt := + .exprStmt (.lit + "if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }") -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>. - return #[outArr, insertCall, + return #[outArr, insertCall, budgetCheck, .returnStmt (.call (.var "Ok") #[.var "__ret"])] | .match valIdx cases dflt? => do -- Each arm body executes from the SAME value-stack snapshot as @@ -972,7 +980,8 @@ def optionalExecuteUses : Array (String × String) := #[ /-- Build the `use aiur::execute::{...};` block, including only items whose search token appears in `body`. -/ def emitConditionalImports (body : String) : String := Id.run do - let always : Array String := #["ExecError", "IOBuffer", "QueryRecord"] + let always : Array String := + #["ExecError", "IOBuffer", "QueryRecord", "record_budget_exceeded"] let mut items : Array String := always for (path, token) in optionalExecuteUses do if (body.splitOn token).length > 1 then diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean index 469fda642..3c9dbe756 100644 --- a/Ix/Cli/BenchCmd.lean +++ b/Ix/Cli/BenchCmd.lean @@ -38,6 +38,7 @@ module public import Cli public import Lean.Data.Json public import Ix.Benchmark.Results +public import Ix.Cli.CheckCmd public import Ix.Cli.ConstsFile public section @@ -277,30 +278,28 @@ def backendSpecs : List BackendSpec := [ ("recursive-proof-size", "0.05", "_"), ("prove-time", "0.10", "_"), ("proof-size", "0.05", "_"), ("verify-time", "0.10", "_"), ("peak-rss", "0.10", "_")] }, - -- The Aiur shard pipeline: profile the env's touch graph, pack at the - -- pinned budget (`aiurShardBudgetGb`), execute the three - -- heaviest-predicted shards through the native kernel — the regime the - -- per-constant aiur rows never enter (a single-constant run faults a - -- tiny closure). The planner metrics only drop on a real ingress/packer - -- win, but they are NOT exactly reproducible — profile worker - -- interleaving wobbles the touch sets a little (measured ±2 shards on - -- InitStd's ~118) — so they ride tight 5% upper bands instead of pins; - -- a real regression (or win) moves them by integer factors. - -- pred-floor-ram sits at the pack cap whenever the env is larger than - -- one shard, so its band guards CAP OVERFLOW (an atomic block packed - -- above budget), not ordinary growth; it is tracked but not plotted — - -- the heavy execution measures the real thing. heavy-* slugs are - -- count-neutral (mean time / max RSS over the sample) so the trend - -- lines survive tuning the sample size. Plan wall time is logged by - -- the run, not uploaded — a diagnostic, not a trend. + -- The Aiur shard pipeline: one whole-env measured scan (`ix shard + -- scan`) at the pinned budget (`aiurShardBudgetGb`) — the FULL check + -- schedule executes through the codegen'd kernel as thin-frontier + -- CheckEnv claims with a running FFT readout, so the row tracks the + -- regime the per-constant aiur rows never enter (a single-constant run + -- faults a tiny closure). scan-time is the whole-env execution wall, + -- peak-rss the scan process tree's high-water; shards and the measured + -- max/total per-shard cost come from the manifest the scan writes. + -- fft-cost is the env's TOTAL measured fft — the same raw unit and + -- slug as the per-constant aiur rows, so the whole-env series joins + -- the existing Aiur FFT cost plot. The scan is deterministic — identical partitions across runs + -- on Init and InitStd — so the count and cost slugs ride 0/2% upper + -- bands: a regression can only move them up, and a legitimate kernel or + -- packer win lowers them freely. { name := "aiur-shard", defaultMode := "execute", inputs := .perEnv, testbeds := [("execute", "aiur-shard-x64-32x")], - metrics := [("execute", ["shards", "pred-floor-ram", "union-bytes", - "heavy-execute-time", "heavy-peak-rss"])], - thresholds := [("shards", "0.05", "_"), ("pred-floor-ram", "0.05", "_"), - ("union-bytes", "0.05", "_"), - ("heavy-execute-time", "0.10", "_"), - ("heavy-peak-rss", "0.10", "_")] }, + metrics := [("execute", ["scan-time", "peak-rss", "shards", + "max-shard-fft", "fft-cost"])], + thresholds := [("shards", "0", "_"), ("max-shard-fft", "0.02", "_"), + ("fft-cost", "0.02", "_"), + ("scan-time", "0.10", "_"), + ("peak-rss", "0.10", "_")] }, { name := "zisk", defaultMode := "execute", inputs := .perConstant, testbeds := [("execute", "zisk-check-execute-x64-32x")], metrics := [("execute", ["execute-time", "throughput", "peak-rss", @@ -845,87 +844,46 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do return exitUsage let ixe ← ensureIxe repo info ((p.flag? "ixe").map (·.as! String)) let ix ← resolveBin repo "ix" - let prof := s!"{repo}/{env}-shardbench.ixprof" let manifest := s!"{repo}/{env}-shardbench.ixes" let budget := (p.flag? "shard-budget").map (·.as! Nat) |>.getD aiurShardBudgetGb - -- Plan: profile (touch graph) + pack. Wall time is logged, not - -- uploaded — a diagnostic, not a tracked trend. - let t0 ← IO.monoMsNow - let e1 ← runGuarded watchdog ceilingGb ix - #["profile", ixe, "--out", prof, "--backend", "aiur"] - if e1 != 0 then - IO.eprintln s!"[bench] ix profile failed (exit {e1})" - return 1 - let e2 ← runGuarded watchdog ceilingGb ix - #["shard", prof, "--backend", "aiur", "--max-ram", toString budget, - "--out", manifest] - if e2 != 0 then - IO.eprintln s!"[bench] ix shard failed (exit {e2})" + -- One whole-env measured scan: executes the entire check schedule as + -- thin-frontier CheckEnv claims and writes the manifest with MEASURED + -- per-shard fft. The tool self-reports scan-time/peak-rss through + -- the rows contract (env load excluded from the timed window, RSS = + -- process-tree high-water). A kill (≥128) records `oom`/`crash` — the + -- honest row for a box the scan no longer fits; any other nonzero + -- exit is a genuine kernel rejection and fails the run. + let exit ← runGuarded watchdog ceilingGb ix + #["shard", ixe, "--max-ram", toString budget, + "--out", manifest, "--json", out, "--json-name", info.name] + if exit ≥ 128 then + let status := killStatus exit + IO.eprintln s!"[bench] scan killed (exit {exit}); recording {status}" + markKilled out info.name status + return 0 + if exit != 0 then + IO.eprintln s!"[bench] ix shard scan failed (exit {exit})" return 1 - IO.eprintln s!"[bench] plan (profile + pack) took {((← IO.monoMsNow) - t0).toFloat / 1000.0}s" - -- The packer's costs sidecar, one row per shard: - -- `shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,pred_ram_gib,pred_prove_s`. - -- `pred_ram_gib` prints with two decimals, so dropping the dot yields - -- centi-GiB as a Nat sort key. - let mut planRows : Array (Nat × Nat × Nat) := #[] -- (shard, centiGiB, unionBytes) - for line in (← IO.FS.readFile (manifest ++ ".costs.csv")).splitOn "\n" do - match line.splitOn "," with - | [k, union, _, _, _, _, _, _, pr, _] => - match k.toNat?, union.toNat?, ((pr.replace "." "").toNat?) with - | some k, some u, some c => planRows := planRows.push (k, c, u) - | _, _, _ => pure () - | _ => pure () - if planRows.isEmpty then - IO.eprintln s!"[bench] no shard rows parsed from {manifest}.costs.csv" + -- Partition metrics straight from the manifest's tagged costs + -- (measured fft): count, heaviest shard, and the total — the + -- deterministic trend lines a kernel or packer change moves. + match Ix.Cli.CheckCmd.parseIxesShards (← IO.FS.readBinFile manifest) with + | .error e => + IO.eprintln s!"[bench] manifest parse failed: {e}" return 1 - let floorCenti := planRows.foldl (fun m r => max m r.2.1) 0 - let unionBytes := planRows.foldl (fun s r => s + r.2.2) 0 - writeRow out info.name "ok" - [ ("shards", Lean.toJson planRows.size) - , ("pred-floor-ram", jsonRound 2 (floorCenti.toFloat / 100.0)) - , ("union-bytes", Lean.toJson unionBytes) ] - -- Execute the three heaviest-predicted shards — where a model miss or - -- kernel regression hits first, and where an ingress win is largest. - -- One process per shard (a kill costs that shard); the tool excludes - -- its env parse from the timed window and self-reports the row. A - -- kill (≥128) records `oom`/`crash` and the walk continues; any other - -- nonzero exit is a genuine kernel rejection and fails the run. - let byWeight := planRows.qsort (fun a b => a.2.1 > b.2.1) - let mut greens : Array String := #[] - for r in byWeight.extract 0 3 do - let rowName := s!"{info.name}/shard-{r.1}" - let exit ← runGuarded watchdog ceilingGb ix - #["check", "--ixe", ixe, "--ixes", manifest, "--shard", toString r.1, - "--json", out, "--json-name", rowName] - if exit == 0 then - greens := greens.push rowName - else if exit ≥ 128 then - let status := killStatus exit - IO.eprintln s!"[bench] '{rowName}' killed (exit {exit}); recording {status}" - markKilled out rowName status - else - IO.eprintln s!"[bench] '{rowName}' failed to check (exit {exit})" + | .ok shardRows => + if shardRows.isEmpty then + IO.eprintln s!"[bench] empty partition in {manifest}" return 1 - -- Headline aggregates on the env row, absent unless all three heavy - -- sub-rows completed — a missing aggregate (an OOM'd shard) is the - -- honest signal. Mean time and max RSS, not sums: count-robust, so - -- the sample size is a tuning knob and not part of the measures' - -- identity. - let rows ← readRows out - let getF (row : Lean.Json) (key : String) : Option Float := - match (row.getObjVal? key).toOption with - | some (.num n) => some n.toFloat - | _ => none - let subs := greens.filterMap fun n => (rows.getObjVal? n).toOption - let times := subs.filterMap (getF · "execute-time") - let rsss := subs.filterMap (getF · "peak-rss") - IO.eprintln s!"[bench] heavy walk: {greens.size}/3 green" - if times.size == 3 && rsss.size == 3 then + let maxFft := shardRows.foldl (fun m r => max m r.cost) 0 + let totalFft := shardRows.foldl (fun s r => s + r.cost) 0 + let rows ← readRows out if let some envRow := (rows.getObjVal? info.name).toOption then - writeEntry out info.name <| (envRow.setObjVal! "heavy-execute-time" - (jsonRound 3 ((times.foldl (· + ·) 0.0) / times.size.toFloat))).setObjVal! - "heavy-peak-rss" (jsonRound 0 (rsss.foldl max 0.0)) + writeEntry out info.name <| + ((envRow.setObjVal! "shards" (Lean.toJson shardRows.size)).setObjVal! + "max-shard-fft" (Lean.toJson maxFft)).setObjVal! + "fft-cost" (Lean.toJson totalFft) | "zisk" | "sp1" => if mode != "execute" then p.printError s!"error: {backend} supports only execute mode" @@ -1034,7 +992,7 @@ def benchRunCmd : Cli.Cmd := `[Cli| "shard-only"; "Restrict to shard_target rows" ixe : String; "Path to an existing .ixe env to use (default: compile fresh; ignored by the compile backend)" "ceiling-gb" : Nat; "RAM watchdog ceiling in GB (default: machine RAM minus 15 GB)" - "shard-budget" : Nat; "aiur-shard only: pinned `ix shard --max-ram` packing budget in GiB (default 250, the deliverable prove box). Change it only knowingly — the bencher baseline is keyed to the same partition problem." + "shard-budget" : Nat; "aiur-shard only: pinned `ix shard --max-ram` budget in GiB (default 250, the deliverable prove box). Change it only knowingly — the bencher baseline is keyed to the same partition problem." watchdog : String; "Watchdog wrapper path (default: /.github/scripts/watchdog.sh; missing = run unguarded)" ] diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index e83f795e7..51c3e729c 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -365,34 +365,61 @@ private def ixesAddr : IxesP Address := do if p + 32 ≤ b.size then modify (fun _ => (b, p + 32)); pure ⟨b.extract p (p + 32)⟩ else throw "ixes: truncated (expected a 32-byte address)" -/-- Parse every shard's owned block addresses from a serialized `.ixes` - manifest (`ShardManifest::to_bytes`, `src/ix/shard.rs`): - magic(8) ‖ total_cross_ingress(u128) ‖ num_shards(u32) ‖ per shard - { id(u32) ‖ heartbeats(u64) ‖ own_size(u64) ‖ cross_ingress(u64) ‖ - assumption_root(u8 tag + 32?) ‖ blocks(u32 len + 32·len) ‖ - foreign_blocks(u32 len + 32·len) }. +private def ixesU64 : IxesP Nat := do + let mut v : Nat := 0 + for i in [0:8] do + v := v ||| ((← ixesU8).toNat <<< (8 * i)) + pure v + +/-- One shard row of a parsed `.ixes` manifest: the owned block addresses + plus the planner cost (`ShardCost` in `crates/kernel/src/shard.rs` — + `costTag` 0 = unknown, 1 = profile heartbeats, 2 = Zisk cost units, + 3 = Aiur fft; `cost` is the scalar, comparable within one manifest). -/ +structure IxesShard where + blocks : Array Address + costTag : UInt8 + cost : Nat + +/-- Parse every shard of a serialized `.ixes` manifest + (`ShardManifest::to_bytes`, `crates/kernel/src/shard.rs`, format v2): + magic("IXES\0\0\0" ++ version) ‖ total_cross_ingress(u128) ‖ + num_shards(u32) ‖ per shard + { id(u32) ‖ cost_tag(u8) ‖ cost(u64) ‖ own_size(u64) ‖ + cross_ingress(u64) ‖ assumption_root(u8 tag + 32?) ‖ + blocks(u32 len + 32·len) ‖ foreign_blocks(u32 len + 32·len) }. Bounds-checked: a truncated/malformed file yields `.error`, never a panic. -/ -def parseIxesAllShards (bytes : ByteArray) : Except String (Array (Array Address)) := - let go : IxesP (Array (Array Address)) := do +def parseIxesShards (bytes : ByteArray) : Except String (Array IxesShard) := + let go : IxesP (Array IxesShard) := do let m0 ← ixesU8; let m1 ← ixesU8; let m2 ← ixesU8; let m3 ← ixesU8 if !(m0 == 0x49 && m1 == 0x58 && m2 == 0x45 && m3 == 0x53) then throw "not an .ixes file (bad magic)" - ixesSkip 4 -- rest of the 8-byte magic + ixesSkip 3 -- reserved zero bytes of the 8-byte magic + let version ← ixesU8 + if version != 2 then + throw s!"unsupported .ixes format version {version} (expected 2) — \ + regenerate the manifest with the current `ix shard`" ixesSkip 16 -- total_cross_ingress (u128) let n ← ixesU32 - let mut shards : Array (Array Address) := #[] + let mut shards : Array IxesShard := #[] for _ in [0:n.toNat] do - ixesSkip (4 + 8 + 8 + 8) -- id + heartbeats + own_size + cross_ingress + ixesSkip 4 -- id + let costTag ← ixesU8 + let cost ← ixesU64 + ixesSkip (8 + 8) -- own_size + cross_ingress if (← ixesU8) == 1 then ixesSkip 32 -- assumption_root present let blen ← ixesU32 let mut blocks : Array Address := #[] for _ in [0:blen.toNat] do blocks := blocks.push (← ixesAddr) ixesSkip ((← ixesU32).toNat * 32) -- skip foreign_blocks - shards := shards.push blocks + shards := shards.push { blocks, costTag, cost } pure shards go.run' (bytes, 0) +/-- The owned block addresses of every shard (cost columns dropped). -/ +def parseIxesAllShards (bytes : ByteArray) : Except String (Array (Array Address)) := + (parseIxesShards bytes).map (·.map (·.blocks)) + /-- The check-schedule block address of a constant: a projection collapses to its SCC/Muts wrapper (`p.block`); everything else is its own block. Mirrors `check_schedule_block_addr` (`src/ffi/kernel.rs`). -/ @@ -639,7 +666,10 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | some other => IO.eprintln s!"error: --interp expects \"source\" or \"bytecode\", got \"{other}\"" return 1 - let keepGoing := p.hasFlag "keep-going" + let keepGoing := p.hasFlag "no-fail-fast" + if keepGoing && p.hasFlag "fail-fast" then + p.printError "error: --fail-fast and --no-fail-fast are mutually exclusive" + return 1 let statsOut : Option String := (p.flag? "stats-out").map (·.as! String) let ixePath : Option String := @@ -721,7 +751,8 @@ def checkCmd : Cli.Cmd := `[Cli| FLAGS: interp : String; "Use an interpreter instead of the codegen'd IxVM Rust kernel. Modes: `source` = Aiur source interpreter (richer per-execution error diagnostics, slowest); `bytecode` = generic Aiur bytecode interpreter (skips the regen + cargo rebuild cycle when iterating on `Ix/IxVM/*.lean`). Omit the flag entirely for the native codegen kernel." - "keep-going"; "Continue past failures and report them at the end instead of halting on the first." + "fail-fast"; "Halt on the first failure (the default; flag accepted for explicitness)." + "no-fail-fast"; "Continue past failures and report them at the end instead of halting on the first." "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)." "stats-out" : String; "Redirect the per-circuit statistics dump to this file (only used when exactly one constant is targeted)." diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 18bf71d8e..23bed6d4f 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -218,29 +218,21 @@ def runShardProveAllNative (manifestPath : String) (envHandle : Aiur.EnvHandle) verifies (circuit changed?) — re-proving" | none => pure () let pending := (List.range shards.size).filter (fun k => !done.contains k) - -- Largest-predicted-RAM first. The RAM model carries a content residual - -- it cannot see (the klimbs blind spot), so if any shard is going to - -- breach the watchdog it is one of the heaviest — proving those first - -- surfaces a failure in the opening minutes instead of hours in, and - -- everything after the heavy head is strictly safer than what already - -- passed. Predictions come from the packer's costs sidecar; without - -- one, manifest order stands. + -- Largest-cost first, straight from the manifest's per-shard tagged + -- cost (measured Mfft on scan manifests, model-predicted on packer + -- manifests). If any shard is going to breach the watchdog it is one + -- of the heaviest — proving those first surfaces a failure in the + -- opening minutes instead of hours in, and everything after the heavy + -- head is strictly safer than what already passed. A manifest without + -- costs (all-unknown) degrades to manifest order. let pending : List Nat ← do - let costs := manifestPath ++ ".costs.csv" - if !(← System.FilePath.pathExists costs) then - IO.println s!"[prove] no costs sidecar ({costs}); proving in manifest order" + match Ix.Cli.CheckCmd.parseIxesShards (← IO.FS.readBinFile manifestPath) with + | .error e => + IO.println s!"[prove] manifest cost parse failed ({e}); proving in manifest order" pure pending - else - -- `pred_ram_gib` is column 8 of the sidecar, printed with two - -- decimals, so dropping the dot yields centi-GiB as a Nat sort key. - let mut ram : Std.HashMap Nat Nat := {} - for line in (← IO.FS.readFile costs).splitOn "\n" do - let fs := line.splitOn "," - match fs[0]?.bind (·.toNat?), fs[8]?.bind (fun pr => (pr.replace "." "").toNat?) with - | some k, some centi => ram := ram.insert k centi - | _, _ => pure () + | .ok rows => pure <| pending.mergeSort (fun a b => - (ram.get? a).getD 0 ≥ (ram.get? b).getD 0) + (rows[a]?.map (·.cost)).getD 0 ≥ (rows[b]?.map (·.cost)).getD 0) IO.println s!"[prove] {shards.size} shards: {done.size} already proven \ (cache {proofsDir}), {pending.length} pending (heaviest first)" let recordProof (r : ProofRow) : IO Unit := @@ -297,7 +289,10 @@ def runShardProveAllNative (manifestPath : String) (envHandle : Aiur.EnvHandle) return 0 def runProveCmd (p : Cli.Parsed) : IO UInt32 := do - let keepGoing := p.hasFlag "keep-going" + let keepGoing := p.hasFlag "no-fail-fast" + if keepGoing && p.hasFlag "fail-fast" then + p.printError "error: --fail-fast and --no-fail-fast are mutually exclusive" + return 1 let ixePath : Option String := (p.flag? "ixe").map (·.as! String) let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList @@ -342,7 +337,8 @@ def proveCmd : Cli.Cmd := `[Cli| "Generate a STARK proof for an `Ix.Claim` (mirrors `ix check`'s CLI shape)" FLAGS: - "keep-going"; "Continue past failures and report them at the end instead of halting on the first." + "fail-fast"; "Halt on the first failure (the default; flag accepted for explicitness)." + "no-fail-fast"; "Continue past failures and report them at the end instead of halting on the first." "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, proves the persisted claim against the `--ixe` env (single proof, skips per-const iteration)." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: prove shard K. Without --shard: prove every shard in the partition." diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index 151607ce4..131eea039 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -1,19 +1,33 @@ /- - `ix shard `: partition a profiled environment into shards, - minimizing cross-shard delta-unfold ingress (see `plans/sharding.md`). + `ix shard `: partition an environment into shards, dispatched on + the input type. - Two modes (precedence in `runShardCmd`): + `.ixe` input — the default, Aiur mode: **measured scan-and-cut**. The + env's check schedule executes through the codegen'd Aiur kernel as + thin-frontier `CheckEnv` claims with a running FFT readout, and shard + boundaries are cut where the measured cost reaches the `--max-ram` + budget's FFT equivalent (see `crates/ffi/src/aiur/scan.rs`). No profile + pass, no cost model — the manifest carries the MEASURED per-shard cost. + + `.ixe` input with `--backend zisk`: Zisk's planner from the env in one + command — the Rust-kernel profiling pass writes `.ixprof`, then + the guest-cost packer runs on it (the profile is kept: re-tuning the + budget is pure offline graph work on the `.ixprof`). + + `.ixprof` input — the profile-driven packer directly (Zisk default; + the Aiur model packer stays reachable via `--backend aiur` for + `--rebudget`): - default / `--max-ram G` / `--max-cycles C`: **bin-pack to a per-shard cycle/RAM cap** — the fewest shards that each stay under the budget, each packed as full as the dependency structure allows (no `--max-ram` ⇒ sized to detected system RAM). Not balanced: packing yields the minimal shard count. - `--shards N`: force exactly `N` **balanced** min-cut shards (manual override). - Reads the `.ixprof` produced by `ix profile` (pure offline graph work, so the - budget/`N` is cheap to re-tune without re-running the kernel). Writes a `.ixes` - manifest and prints a what-if report (per-shard cost + total cross-shard - ingress). The partitioner is self-contained — no external graph-library - dependency. + The `.ixprof` comes from `ix profile` (pure offline graph work, so the + budget/`N` is cheap to re-tune without re-running the kernel). Both modes + write a `.ixes` manifest (format v2, per-shard tagged costs) and print a + what-if report. The partitioner is self-contained — no external + graph-library dependency. `ix shard extract --consts `: the pipeline's scoping step — extract the named constants' dependency closure from a serialized @@ -25,7 +39,13 @@ -/ module public import Cli +public import Ix.Aiur.Compiler +public import Ix.Aiur.Protocol +public import Ix.Benchmark.Results +public import Ix.IxVM +public import Ix.IxVM.Toplevel public import Ix.KernelCheck +public import Ix.TracingTexray public import Ix.Cli.ConstsFile public section @@ -34,6 +54,67 @@ open Ix.KernelCheck namespace Ix.Cli.ShardCmd +/-- Shard a `.ixe` env by MEASURED cost (the default `ix shard` mode for + Aiur): execute the check schedule through the codegen'd Aiur kernel + with a running FFT readout and cut boundaries at the RAM budget's FFT + equivalent. No profile, no prediction; the manifest carries measured + per-shard cost. -/ +def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do + let outPath : String := + match p.flag? "out" with + | some flag => flag.as! String + | none => + let base := if ixePath.endsWith ".ixe" then (ixePath.dropEnd 4).toString else ixePath + base ++ ".ixes" + let budget := (p.flag? "max-ram").map (·.as! Nat) |>.getD 250 + let eps := (p.flag? "eps").map (·.as! Nat) |>.getD 5 + let workers := (p.flag? "workers").map (·.as! Nat) |>.getD 0 + let noFailFast := p.hasFlag "no-fail-fast" + if noFailFast && p.hasFlag "fail-fast" then + p.printError "error: --fail-fast and --no-fail-fast are mutually exclusive" + return 1 + let toplevel ← match IxVM.ixVM with + | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 + | .ok t => pure t + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 + | .ok c => pure c + let funIdx ← match compiled.getFuncIdx `verify_claim with + | some i => pure i + | none => IO.eprintln "error: verify_claim missing"; return 1 + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h + let workersDesc := if workers == 0 then "auto" else toString workers + IO.println s!"Scanning {ixePath} @ {budget} GiB (ε {eps}%, {workersDesc} workers)" + (← IO.getStdout).flush + -- `benchJson = (out, rowName)` reports the scan as a benchmark row (the + -- `aiur-shard` bench backend): `scan-time` windows the scan itself — the + -- env mmap and toplevel build are excluded, so the measure tracks the + -- kernel execution, not the loader — while `peak-rss` is the process + -- tree's absolute high-water, matching the check rows' semantics. + let benchJson := (p.flag? "json").map fun f => + (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "scan") + if benchJson.isSome then + TracingTexray.startSampler + TracingTexray.resetPeakTreeRss + let start ← IO.monoMsNow + match Aiur.Bytecode.Toplevel.scanShardsWithEnv compiled.bytecode funIdx + envHandle (toString budget) (toString eps) (toString workers) + (if noFailFast then "0" else "1") outPath with + | .ok () => + if let some (out, rowName) := benchJson then + let secs := ((← IO.monoMsNow) - start).toFloat / 1000.0 + let peakRss ← TracingTexray.peakTreeRssBytes + Ix.Benchmark.Results.writeRow out rowName "ok" + [ ("scan-time", Ix.Benchmark.Results.jsonRound 3 secs) + , ("peak-rss", Lean.toJson peakRss) ] + IO.println s!"[shard scan] wrote {outPath} (+ .costs.csv, measured)" + return 0 + | .error e => + IO.eprintln s!"error: shard scan failed: {e}" + return 1 + def runShardExtractCmd (p : Cli.Parsed) : IO UInt32 := do let some pathArg := p.positionalArg? "path" | p.printError "error: must specify to a .ixe file" @@ -73,9 +154,28 @@ def shardExtractCmd : Cli.Cmd := `[Cli| def runShardCmd (p : Cli.Parsed) : IO UInt32 := do let some pathArg := p.positionalArg? "path" - | p.printError "error: must specify to a .ixprof file" + | p.printError "error: must specify to a .ixe (measured scan) or .ixprof (profile packer)" + return 1 + let path := pathArg.as! String + -- Dispatch on the input: a `.ixe` env runs the backend's own planner + -- from the env itself — aiur (default) is the measured scan-and-cut; + -- zisk chains the Rust-kernel profiling pass into the guest-cost + -- packer, leaving the `.ixprof` next to the env so the budget can be + -- re-tuned offline without re-running the kernel. A `.ixprof` input + -- skips straight to the profile-driven packer. + let mut espPath := path + if path.endsWith ".ixe" then + match (p.flag? "backend").map (·.as! String) |>.getD "aiur" with + | "aiur" => return ← runShardScan p path + | "zisk" => + let prof := (path.dropEnd 4).toString ++ ".ixprof" + IO.println s!"Profiling {path} → {prof} (Rust-kernel pass, zisk counters)" + (← IO.getStdout).flush + rsProfileAnonFFI path prof true true "0" "zisk" + espPath := prof + | other => + p.printError s!"error: --backend must be aiur or zisk (got {other})" return 1 - let espPath := pathArg.as! String let balancePct : Nat := match p.flag? "balance" with | some flag => flag.as! Nat @@ -149,21 +249,27 @@ end Ix.Cli.ShardCmd open Ix.Cli.ShardCmd in def shardCmd : Cli.Cmd := `[Cli| "shard" VIA runShardCmd; - "Partition a `.ixprof` into shards: pack to a RAM/cycle cap (default) or N balanced shards" + "Partition an env into shards. A `.ixe` input runs the MEASURED Aiur scan-and-cut (default; no profile pass); a `.ixprof` input runs the profile-driven packer (Zisk)" FLAGS: - shards : Nat; "Fixed number of shards N (overrides the default budget sizing)" - "max-cycles" : Nat; "Per-shard guest-cycle budget (overrides the default RAM sizing)" - "max-ram" : Nat; "Per-shard host-RAM budget, GiB (default: detected system RAM)" - balance : Nat; "Per-bisection balance tolerance, percent (default 5)" - parallelism : Nat; "Provers assumed for the prove-time estimate (default 1 = sequential)" - backend : String; "Packing cost model: zisk (default, guest-STEP cap) or aiur (RAM model; use with --max-ram)" - rebudget : Nat; "Surgically split shard K of --manifest at the smaller --max-ram budget; every other shard is copied verbatim so its cached claims/proofs stay valid." + "max-ram" : Nat; "Per-shard host-RAM budget, GiB (scan default 250; .ixprof default: detected system RAM)" + backend : String; "Planner: aiur (default on `.ixe`: measured scan) or zisk (`.ixe`: profile pass + guest-cost pack in one command; `.ixprof`: pack directly). On a `.ixprof`, `aiur` selects the model packer (--rebudget's path)" + out : String; "Output .ixes manifest path (default: input basename + .ixes)" + eps : Nat; "Scan only: pre-charged cut headroom, percent (default 5): covers the incremental claim-walk overcount and the merge pass's fft-sum conservatism" + workers : Nat; "Scan only: parallel chunk scanners (default 0 = autoscale to cores and detected RAM). Each holds one segment's query record and faulted witness, so workers × segment footprint must fit the box" + "fail-fast"; "Scan: halt on the first kernel-rejected block (the default; flag accepted for explicitness)." + "no-fail-fast"; "Scan: skip kernel-rejected blocks (named as skipped, excluded from the partition, listed in .failed.csv). The manifest then does not cover them — the downstream coverage gate reports exactly which." + json : String; "Scan only: benchmark results JSON accumulator — append a `scan-time`/`peak-rss` row. Used by `ix bench run --backend aiur-shard`." + "json-name" : String; "Row name for --json (default: scan)." + shards : Nat; ".ixprof only: fixed number of shards N (overrides the budget sizing)" + "max-cycles" : Nat; ".ixprof only: per-shard guest-cycle budget (overrides the RAM sizing)" + balance : Nat; ".ixprof only: per-bisection balance tolerance, percent (default 5)" + parallelism : Nat; ".ixprof only: provers assumed for the prove-time estimate (default 1 = sequential)" + rebudget : Nat; ".ixprof only: surgically split shard K of --manifest at the smaller --max-ram budget; every other shard is copied verbatim so its cached claims/proofs stay valid." manifest : String; "Input .ixes manifest to split (with --rebudget)." - out : String; "Output .ixes manifest path (default: .ixes, e.g. init.ixprof → init.ixes)" ARGS: - path : String; "Path to a .ixprof produced by `ix profile`" + path : String; "A serialized `.ixe` env (measured scan) or a `.ixprof` from `ix profile` (profile packer)" SUBCOMMANDS: shardExtractCmd diff --git a/Tests/Ix/Kernel/ShardPipeline.lean b/Tests/Ix/Kernel/ShardPipeline.lean index e2d21f783..ef73f6389 100644 --- a/Tests/Ix/Kernel/ShardPipeline.lean +++ b/Tests/Ix/Kernel/ShardPipeline.lean @@ -87,6 +87,30 @@ def shardPipelineTests (env : Lean.Environment) let envHandle ← match Aiur.EnvHandle.fromIxe ixe.toString with | .error e => throw <| IO.userError s!"EnvHandle.fromIxe: {e}" | .ok h => pure h + + -- Scan-and-cut over the same env: measured thin-frontier segments → + -- merge/re-measure → manifest. The budget barely clears the RAM-model + -- base, so the tiny env still exercises cuts, the merge pass, and the + -- refine rounds; the scanned partition must cover and check like the + -- profiled one. + let scanIxes := dir / "pipeline-scan.ixes" + let scanFunIdx ← match compiled.getFuncIdx `verify_claim with + | some i => pure i + | none => throw <| IO.userError "verify_claim missing" + match Aiur.Bytecode.Toplevel.scanShardsWithEnv compiled.bytecode scanFunIdx + envHandle "20" "5" "2" "1" scanIxes.toString with + | .error e => throw <| IO.userError s!"shard scan failed: {e}" + | .ok () => pure () + let (_, scanShards) ← + match ← Ix.Cli.CheckCmd.loadEnvAndShards scanIxes.toString ixe.toString with + | .error e => throw <| IO.userError s!"scan manifest load failed: {e}" + | .ok r => pure r + tests := tests ++ + test s!"scan produced a covering partition ({scanShards.size} shard(s))" + (scanShards.size ≥ 1) + let scanCheckRc ← Ix.Cli.CheckCmd.runShardManifestAllNative scanIxes.toString + ixe.toString none compiled false none false + tests := tests ++ test "all scanned shards check" (scanCheckRc == 0) let proveRc ← Ix.Cli.ProveCmd.runShardProveAllNative ixes.toString envHandle parsedEnv shards aiurSystem compiled' 1 (some cacheRoot) tests := tests ++ test "batch prove reaches the composed verdict" (proveRc == 0) diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 98647e1b5..b512e8e4a 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -201,6 +201,10 @@ pub enum ExecError { msg: Option, }, MatchNoCase(u64), + /// The thread's record-growth budget was crossed (see + /// [`set_record_byte_budget`]): not a kernel verdict on the claim — the + /// driver that armed the budget re-runs or defers the work. + RecordBudgetExceeded, NoContinuation, StackNotEmpty, InvalidIOKey { @@ -244,6 +248,9 @@ impl std::fmt::Display for ExecError { None => write!(f, "assert_eq mismatch: {lhs} != {rhs}"), }, Self::MatchNoCase(v) => write!(f, "no match case for value {v}"), + Self::RecordBudgetExceeded => { + write!(f, "record byte budget exceeded") + }, Self::NoContinuation => write!(f, "yield without continuation"), Self::StackNotEmpty => { write!(f, "exec entries stack not empty at return") @@ -271,7 +278,13 @@ static QUERY_STATS: std::sync::LazyLock = std::env::var_os("IX_AIUR_QUERY_STATS").is_some() }); -fn dump_query_stats(record: &QueryRecord, tag: &str) { +/// Whether `IX_AIUR_QUERY_STATS=1` is set (the codegen'd execution paths +/// share `QueryRecord`, so callers there gate their own dumps on this). +pub fn query_stats_enabled() -> bool { + *QUERY_STATS +} + +pub fn dump_query_stats(record: &QueryRecord, tag: &str) { let mut rows: Vec<(usize, usize, usize)> = record .function_queries .iter() @@ -304,18 +317,133 @@ impl Toplevel { args: Vec, io_buffer: &mut IOBuffer, ) -> Result<(QueryRecord, Vec), ExecError> { + let mut record = QueryRecord::new(self); + let output = + self.execute_with_record(fun_idx, args, io_buffer, &mut record)?; + Ok((record, output)) + } + + /// Like [`Self::execute`] but accumulating into a caller-owned + /// [`QueryRecord`]: repeated calls share the memo tables, so a query + /// resolved by an earlier call is a hit rather than re-executed. This is + /// how a sequence of independent claims is executed with the same + /// memoization semantics as one combined run (the scan-and-cut sharder's + /// segment loop). + pub fn execute_with_record( + &self, + fun_idx: FunIdx, + args: Vec, + io_buffer: &mut IOBuffer, + record: &mut QueryRecord, + ) -> Result, ExecError> { if !self.functions[fun_idx].entry { return Err(ExecError::NotEntryFunction(fun_idx)); } - let mut record = QueryRecord::new(self); 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, record, io_buffer)?; if *QUERY_STATS { - dump_query_stats(&record, "final"); + dump_query_stats(record, "final"); } - Ok((record, output)) + Ok(output) + } +} + +/// Total FFT cost of a [`QueryRecord`]: `Σ width·height·log2(max(height,2))` +/// over every constrained function circuit plus the memory circuits, with +/// heights = unique memoized queries. Mirrors `Ix/Aiur/Statistics.lean`'s +/// `computeStats.totalFftCost` (function width `layout.totalWidth` = +/// `width + extDegree·max(lookups,1)`; memory width `3 + size + extDegree`; +/// gadget circuits excluded, as there), so a running readout here matches +/// the number the check stats dump prints and the RAM/wall lines are +/// calibrated against. +/// `usize → f64` without a lossy `as` cast: split into `u32` halves, each +/// exactly convertible. Matches `n as f64` bit-for-bit below 2^52 (query +/// counts and widths stay far below) and rounds identically above. +pub fn f64_from_usize(n: usize) -> f64 { + let hi = u32::try_from(n >> 32).expect("usize is at most 64 bits"); + let lo = u32::try_from(n & 0xFFFF_FFFF).expect("masked to u32 range"); + f64::from(hi) * 4_294_967_296.0 + f64::from(lo) +} + +std::thread_local! { + /// Per-thread record-growth budget: `(bytes charged, byte limit)`. + /// Every [`QueryMap::insert`](crate::querymap::QueryMap::insert) charges + /// its entry's retained bytes; execution paths poll + /// [`record_budget_exceeded`] and abort with + /// [`ExecError::RecordBudgetExceeded`] once the limit is crossed. The + /// default limit is `usize::MAX`, so nothing changes unless a driver + /// (the shard scanner) opts a thread in around an execution it must be + /// able to bound — a single dense block can otherwise grow a record by + /// tens of GiB with no interior boundary to act on. + static RECORD_BYTE_BUDGET: std::cell::Cell<(usize, usize)> = + const { std::cell::Cell::new((0, usize::MAX)) }; +} + +/// Arm the calling thread's record-growth budget and zero its counter. +pub fn set_record_byte_budget(limit: usize) { + RECORD_BYTE_BUDGET.with(|c| c.set((0, limit))); +} + +/// Disarm the calling thread's record-growth budget. +pub fn clear_record_byte_budget() { + RECORD_BYTE_BUDGET.with(|c| c.set((0, usize::MAX))); +} + +/// Whether the calling thread has charged past its record-growth limit. +pub fn record_budget_exceeded() -> bool { + RECORD_BYTE_BUDGET.with(|c| { + let (used, limit) = c.get(); + used > limit + }) +} + +pub(crate) fn charge_record_bytes(bytes: usize) { + RECORD_BYTE_BUDGET.with(|c| { + let (used, limit) = c.get(); + c.set((used.saturating_add(bytes), limit)); + }); +} + +/// Approximate resident bytes of a [`QueryRecord`]: retained key/output +/// field elements (8 B each) plus ~13 B of per-entry index overhead +/// (stored hash, table slot, multiplicity). The memory-circuit stores +/// dominate on arithmetic-heavy content, where entries are FFT-cheap +/// (narrow columns) but RAM-heavy — the second resource dimension a +/// RAM-budgeted partition has to price alongside FFT cost. +pub fn record_retained_bytes(record: &QueryRecord) -> usize { + let mut elems = 0usize; + let mut entries = 0usize; + for m in &record.function_queries { + elems += m.retained_elems(); + entries += m.len(); } + for (_, m) in &record.memory_queries { + elems += m.retained_elems(); + entries += m.len(); + } + elems * 8 + entries * 13 +} + +pub fn record_fft_cost(toplevel: &Toplevel, record: &QueryRecord) -> f64 { + const EXT_DEGREE: usize = 2; + fn fft(w: usize, h: usize) -> f64 { + if h == 0 { + 0.0 + } else { + f64_from_usize(w) * f64_from_usize(h) * f64_from_usize(h.max(2)).log2() + } + } + let mut total = 0.0; + for (i, f) in toplevel.functions.iter().enumerate() { + if f.constrained { + let w = f.layout.width() + EXT_DEGREE * f.layout.lookups.max(1); + total += fft(w, record.function_queries[i].len()); + } + } + for (size, qm) in &record.memory_queries { + total += fft(3 + size + EXT_DEGREE, qm.len()); + } + total } enum ExecEntry<'a> { @@ -436,6 +564,9 @@ impl Function { &[ptr], G::from_bool(!unconstrained), ); + if record_budget_exceeded() { + return Err(ExecError::RecordBudgetExceeded); + } map.push(ptr); } }, @@ -758,6 +889,9 @@ impl Function { &output, G::from_bool(!unconstrained), ); + if record_budget_exceeded() { + return Err(ExecError::RecordBudgetExceeded); + } if let Some(CallerState { fun_idx: caller_idx, map: caller_map, diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 56f97306e..44d68ef0c 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -319,6 +319,7 @@ impl QueryMap { } else { debug_assert_eq!(output.len(), self.outs.stride); } + crate::execute::charge_record_bytes((key.len() + output.len()) * 8 + 13); let hash = hash_g_slice(key); let i = u32::try_from(self.mults.entries).expect("query map overflow"); self.keys.push(key); diff --git a/crates/ffi/src/aiur.rs b/crates/ffi/src/aiur.rs index 01ad45ace..d97549b74 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 protocol; +pub mod scan; pub mod toplevel; use aiur::G; diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs new file mode 100644 index 000000000..55ba18c34 --- /dev/null +++ b/crates/ffi/src/aiur/scan.rs @@ -0,0 +1,910 @@ +//! Scan-and-cut sharding: shard boundaries from Aiur's own measured cost. +//! +//! Instead of predicting shard cost from profile counters, the env's check +//! schedule is EXECUTED through the codegen'd circuit kernel with a running +//! FFT-cost readout, and a shard boundary is cut where the measured cost +//! reaches the RAM budget's FFT equivalent. Execution is the mandatory +//! prefix of proving, so the measurement is the prove's own cost, not a +//! proxy — the failure mode where a recorder-side counter under-represents +//! circuit work by a content-dependent factor cannot occur. +//! +//! The measurement unit is the SAME claim the prover pays for: a +//! thin-frontier `CheckEnv` over a prefix of the schedule. Each segment +//! grows its owned prefix adaptively — execute `CheckEnv[lo..lo+k]` against +//! a shared `QueryRecord`, checkpoint the FFT, grow `k` while under the +//! cut — so every constant is checked once per segment and dependencies +//! stop at the assumed frontier. (Per-constant `Check{assumptions: None}` +//! claims are NOT usable here: without a frontier the kernel checks the +//! constant's whole dependency closure, which measures 100-1000× the real +//! per-block shard cost and rederives the env spine per segment.) The +//! grown record over-counts slightly — each growth step re-walks its +//! claim's owned/assumption trees, and members assumed at step `i` may be +//! checked at step `i+1` — so the checkpoint is a mild upper bound on the +//! emitted shard's cold cost: the safe direction for packing. +//! +//! Witness bytes are served LAZILY (`EnvFaultSource`): only the claim +//! wires are seeded per attempt, and constant/hint/blob bytes materialize +//! on first fault, so a worker's buffer holds one segment's touched set — +//! exactly the real shard-prove start state. +//! +//! Parallelism follows SP1's splicing design: the schedule is pre-cut into +//! coarse chunks whose edges are FORCED shard boundaries, and chunks scan +//! concurrently. A segment's start state is a cold memo table — exactly +//! the state a real shard prove begins in — so chunk-parallel scanning is +//! faithful by construction. A post-pass merges adjacent segments whose +//! FFT sum stays under the cut (the sum over-estimates the merged cost, so +//! the merged shard still fits), which decouples the chunk count — a pure +//! parallelism knob — from pack density. The schedule itself is the +//! byte-weighted min-cut linearization of the env's reference graph +//! (static, no profiling run), which keeps closure-overlapping blocks +//! adjacent so intra-segment memoization absorbs shared-dependency work. +//! +//! What crosses a boundary: nothing. Constants are order-independent +//! obligations; cross-shard soundness is the thin-frontier assumption tree +//! the claim layer already provides. + +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::{Arc, Mutex}; + +use rustc_hash::FxHashMap; + +use aiur::{ + bytecode::Toplevel, + execute::{ + ExecError, IOBuffer, QueryRecord, dump_query_stats, f64_from_usize, + query_stats_enabled, record_fft_cost, record_retained_bytes, + set_record_byte_budget, + }, +}; +use ix_common::address::Address; +use ix_kernel::profile::{OpCounts, ProfileBuilder}; +use ix_kernel::shard::{ + AIUR_RAM_BASE_GIB, AIUR_RAM_GIB_PER_BFFT, AIUR_RAM_USABLE_FRAC, ShardCost, + ShardInfo, ShardManifest, aiur_prove_secs_for_fft, aiur_ram_gib_for_fft, + balanced_agg_tree, cost_fft, cut_coherent_order, +}; +use ixon::constant::ConstantInfo as IxonCI; +use ixon::env::Env as IxonEnv; +use ixvm_codegen::aiur_ixvm_runner::execute_ixvm_with_record; +use ixvm_codegen::aiur_ixvm_witness::{ + EnvFaultSource, seed_shard_check_env_claim, +}; + +/// Bytes per GiB. +const GIB: f64 = 1_073_741_824.0; + +/// GiB → bytes for budget caps, via the same lossless decimal +/// round-trip as [`cost_fft`] (no `as` cast): budgets are small positive +/// magnitudes, exact to the byte at every realistic scale. +fn gib_to_bytes(gib: f64) -> usize { + format!("{:.0}", (gib * GIB).max(0.0)).parse().unwrap_or(usize::MAX) +} + +/// Fraction of detected system RAM the worker fleet may plan against. +/// The fleet bound is arithmetic, not reactive: `workers × record cap` +/// is chosen under this line at startup, and the per-worker cap is +/// enforced inside execution, so measured RSS never depends on content. +const RAM_CEILING_FRAC: f64 = 0.70; + +/// Current process resident set in GiB (`/proc/self/status` VmRSS); +/// 0 where unreadable (non-Linux). Reported in segment logs. +fn process_rss_gib() -> f64 { + let Ok(s) = std::fs::read_to_string("/proc/self/status") else { + return 0.0; + }; + let Some(rest) = s.lines().find_map(|l| l.strip_prefix("VmRSS:")) else { + return 0.0; + }; + let kib: f64 = + rest.trim().trim_end_matches("kB").trim().parse().unwrap_or(0.0); + kib / 1024.0 / 1024.0 +} + +/// One block of the static schedule: home address, member constants, +/// serialized size. +struct SchedBlock { + addr: Address, + members: Vec
, + size: u64, +} + +/// Fold the env's constants into home blocks (projections and mutual +/// members attribute to their block), with member lists, sizes, and the +/// block-level reference adjacency — all static structure, no execution. +fn schedule_blocks(env: &IxonEnv) -> (Vec, Vec>) { + // Pass 1: home address per constant. + let mut home: FxHashMap = FxHashMap::default(); + for entry in env.consts.iter() { + let (addr, lazy) = (entry.key(), entry.value()); + let Ok(c) = lazy.get() else { continue }; + let h = match &c.info { + IxonCI::IPrj(p) => p.block.clone(), + IxonCI::CPrj(p) => p.block.clone(), + IxonCI::RPrj(p) => p.block.clone(), + IxonCI::DPrj(p) => p.block.clone(), + _ => addr.clone(), + }; + home.insert(addr.clone(), h); + } + // Pass 2: block table (sorted for determinism) + members + sizes. + let mut blocks: FxHashMap = FxHashMap::default(); + for entry in env.consts.iter() { + let (addr, _lazy) = (entry.key(), entry.value()); + let h = home[addr].clone(); + let size = env.get_const_bytes(&h).map_or(0, |b| b.len() as u64); + let b = blocks.entry(h.clone()).or_insert_with(|| SchedBlock { + addr: h.clone(), + members: Vec::new(), + size, + }); + b.members.push(addr.clone()); + } + let mut list: Vec = blocks.into_values().collect(); + list.sort_by(|a, b| a.addr.cmp(&b.addr)); + for b in &mut list { + b.members.sort(); + } + let id_of: FxHashMap<&Address, u32> = list + .iter() + .enumerate() + .map(|(i, b)| (&b.addr, u32::try_from(i).expect("block count exceeds u32"))) + .collect(); + // Pass 3: block-level ref adjacency (constant refs folded to home blocks). + let mut adj: Vec> = vec![Vec::new(); list.len()]; + for entry in env.consts.iter() { + let (addr, lazy) = (entry.key(), entry.value()); + let Ok(c) = lazy.get() else { continue }; + let Some(&hid) = id_of.get(&home[addr]) else { continue }; + for r in &c.refs { + if let Some(rh) = home.get(r) + && let Some(&rid) = id_of.get(rh) + && rid != hid + { + adj[hid as usize].push(rid); + } + } + } + for row in &mut adj { + row.sort_unstable(); + row.dedup(); + } + (list, adj) +} + +/// The byte-weighted min-cut linearization of the block graph. Weights ride +/// the `intern` counter slot (the only op counter in the step-cost formula +/// that we can set to a pure byte value), nets are the ref edges; the +/// bisection keeps closure-overlapping blocks adjacent. +fn static_order( + blocks: &[SchedBlock], + adj: &[Vec], + pieces: usize, +) -> Vec { + let mut b = ProfileBuilder::new(); + for blk in blocks { + let ops = OpCounts { intern_nodes: blk.size, ..OpCounts::default() }; + b.block( + blk.addr.clone(), + 0, + u32::try_from(blk.size).expect("block size exceeds u32"), + u32::try_from(blk.members.len()).expect("member count exceeds u32"), + ops, + ); + } + for (i, row) in adj.iter().enumerate() { + for &r in row { + b.delta_edge(blocks[i].addr.clone(), blocks[r as usize].addr.clone()); + } + } + let profile = b.finish(); + // ProfileBuilder sorts by address and `blocks` is address-sorted, so ids + // coincide; assert the invariant the whole mapping rests on. + assert_eq!(profile.num_blocks(), blocks.len()); + cut_coherent_order(&profile, pieces, 0.05) +} + +/// One scanned segment: its blocks (as schedule ids) and BOTH measured +/// resource terms — FFT cost (prove compute/trace) and retained record +/// bytes (the execute-side store the prove replays into). Record bytes +/// are not derivable from FFT cost: measured GiB-per-BFFT varies ~2x +/// across segments (heavy single blocks run byte-lean, block-dense +/// segments byte-rich), so a RAM budget must price the pair. +struct Segment { + blocks: Vec, + fft: f64, + bytes_gib: f64, +} + +/// Everything a chunk scanner needs besides its own chunk: kernel, env, +/// schedule, and the cut threshold. +struct ScanCtx<'a> { + toplevel: &'a Toplevel, + fun_idx: usize, + env: &'a Arc, + blocks: &'a [SchedBlock], + /// Combined-resource cut: a segment ends when + /// `RAM_GIB_PER_BFFT·fft + record_bytes` reaches this headroom + /// (the budget's usable GiB above the prove base, ε-discounted). + cut_used_gib: f64, + n_chunks: usize, + /// Abort the whole scan on the first kernel-rejected block (the + /// default). With `--no-fail-fast`, such blocks are recorded in + /// `failed` and skipped; the manifest then does not cover them, which + /// the downstream coverage gate reports — a partial partition can + /// never pass as a full-env check. + fail_fast: bool, + /// Blocks whose check claim the kernel rejected, with the error. + failed: &'a Mutex>, + /// Set on a fatal error so every worker bails at its next BLOCK + /// boundary — a failure aborts the fleet in seconds, not after the + /// in-flight ranges drain. + abort: &'a std::sync::atomic::AtomicBool, + /// Per-worker segment-record byte cap, enforced INSIDE block execution + /// via the aiur thread-local budget: a worker's live record can never + /// exceed it, so the fleet's RAM is bounded by `workers × cap` by + /// construction — including through dense regions where a single block + /// grows its record by tens of GiB with no boundary to act on. A block + /// that crosses the cap alone is skipped and named, like a + /// kernel-rejected block: its record alone out-sizes a per-worker share + /// of this box, which at measured byte-per-fft ratios puts its prove + /// far beyond any single-shard budget. (`--workers 1` grants one worker + /// the whole allowance when such a block must be measured anyway.) + seg_byte_budget: usize, +} + +/// Smallest useful per-worker record cap, GiB. Typical segments at any +/// realistic cut carry 3–8 GiB of record (measured 4–10% of the combined +/// cut across envs), so a cap at this floor still lets normal segments +/// reach their cut untouched. +const MIN_WORKER_CAP_GIB: f64 = 8.0; + +/// Joint worker-count / record-cap arithmetic: the fleet plans against +/// `RAM_CEILING_FRAC × box − 10` (decode cache, witness maps, claim +/// trees), workers split it evenly, and each worker's share IS its +/// enforced record cap — the fleet bound is `workers × cap` by +/// construction, no reactive control. Fewer workers means a bigger cap +/// (`--workers 1` grants the whole allowance). Returns `(workers, +/// cap_gib)`; `IX_SCAN_SEG_BYTE_BUDGET_GIB` overrides the cap for tests. +fn fleet_plan(workers: usize, cut_used_gib: f64) -> (usize, f64) { + let cores = std::thread::available_parallelism().map_or(4, usize::from); + let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); + let usable = ram.mul_add(RAM_CEILING_FRAC, -10.0).max(MIN_WORKER_CAP_GIB); + let workers = if workers == 0 { + let by_ram = format!("{:.0}", (usable / MIN_WORKER_CAP_GIB).floor()) + .parse::() + .unwrap_or(1) + .max(1); + cores.saturating_sub(2).max(1).min(by_ram) + } else { + workers + }; + let cap_gib = std::env::var("IX_SCAN_SEG_BYTE_BUDGET_GIB") + .ok() + .and_then(|v| v.parse::().ok()) + .unwrap_or_else(|| (usable / f64_from_usize(workers)).min(cut_used_gib)); + (workers, cap_gib) +} + +/// Scan-and-cut over the whole env: returns the manifest report, writing +/// the manifest and its costs sidecar to `out_path`. +#[allow(clippy::too_many_arguments)] +pub fn scan_shards( + toplevel: &Toplevel, + fun_idx: usize, + env: &Arc, + budget_gib: f64, + eps: f64, + workers: usize, + fail_fast: bool, + out_path: &str, +) -> Result { + let cap_gib = budget_gib * AIUR_RAM_USABLE_FRAC; + if cap_gib <= AIUR_RAM_BASE_GIB { + return Err(format!( + "budget {budget_gib} GiB leaves no headroom over the {AIUR_RAM_BASE_GIB} GiB base" + )); + } + // The ε-discounted headroom above the prove base, in GiB. The cut + // charges BOTH resource terms against it: slope·fft (trace/FFT RAM) + // plus the measured record bytes the prove's execute replays into. + let cut_used_gib = (cap_gib - AIUR_RAM_BASE_GIB) * (1.0 - eps); + // FFT-equivalent of the headroom, for the worker autoscale estimate. + let cut_fft = cut_used_gib / AIUR_RAM_GIB_PER_BFFT * 1e9; + + let (blocks, adj) = schedule_blocks(env); + if blocks.is_empty() { + return Err("empty environment".to_string()); + } + let env_bytes: u64 = blocks.iter().map(|b| b.size).sum(); + let (workers, seg_budget_gib) = fleet_plan(workers, cut_used_gib); + let n_chunks = (workers * 2).min(blocks.len()); + eprintln!( + "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut {:.1} \ + GiB combined (≈{:.1} BFFT fft-only), {seg_budget_gib:.1} GiB record \ + cap per worker", + blocks.len(), + cut_used_gib, + cut_fft / 1e9 + ); + let mut order = static_order(&blocks, &adj, n_chunks.max(16)); + // Debug knob: truncate the schedule to its first N blocks — a + // full-pipeline reproducer over a slice of a huge env, without + // extracting one. The manifest then does NOT cover the env. + if let Some(limit) = std::env::var("IX_SCAN_LIMIT_BLOCKS") + .ok() + .and_then(|v| v.parse::().ok()) + && limit < order.len() + { + eprintln!( + "[scan] IX_SCAN_LIMIT_BLOCKS={limit}: scanning a schedule PREFIX — \ + the manifest will not cover the env" + ); + order.truncate(limit); + } + + // Equal-byte contiguous chunks over the order; edges are forced shard + // boundaries (the parallelism unit); the merge pass below repairs the + // resulting fragmentation, so chunk count is a pure parallelism knob. + let per_chunk = (env_bytes / n_chunks as u64).max(1); + let mut chunks: Vec> = Vec::new(); + let mut cur: Vec = Vec::new(); + let mut acc = 0u64; + for &b in &order { + cur.push(b); + acc += blocks[b as usize].size; + if acc >= per_chunk && chunks.len() + 1 < n_chunks { + chunks.push(std::mem::take(&mut cur)); + acc = 0; + } + } + if !cur.is_empty() { + chunks.push(cur); + } + // Baseline before any execution: the schedule pass decoded every + // constant into the shared env's lazy cache, so this RSS is (cache + + // static structures) — the floor the worker footprints sit on. + eprintln!("[scan] post-schedule baseline rss {:.0}G", process_rss_gib()); + + // Work-stealing ranges: workers pull `(origin chunk, seq, hint, blocks)` + // ranges off a shared deque; a range yields at most `RANGE_SEGMENTS` + // segments, then re-queues its remainder for any idle worker. Dense + // regions — where one equal-byte chunk can hold hours of sequential + // measurement — therefore self-parallelize; the extra forced boundaries + // this creates are repaired by the merge + re-measure pass like any + // others. The split policy is count-based, not time- or RAM-based, so + // the resulting partition does not depend on scheduling (governor sheds + // under RAM pressure excepted — there, safety wins). Segments are + // tagged `(origin, seq)` and sorted at the end, so the final order is + // the schedule order. + let failed: Mutex> = Mutex::new(Vec::new()); + let abort = std::sync::atomic::AtomicBool::new(false); + let ctx = ScanCtx { + toplevel, + fun_idx, + env, + blocks: &blocks, + cut_used_gib, + n_chunks: chunks.len(), + fail_fast, + failed: &failed, + abort: &abort, + seg_byte_budget: gib_to_bytes(seg_budget_gib), + }; + type Range = (u32, u32, Vec); + let queue: Mutex> = Mutex::new( + chunks + .iter() + .enumerate() + .map(|(i, c)| { + (u32::try_from(i).expect("chunk count fits u32"), 0u32, c.clone()) + }) + .collect(), + ); + let in_flight = AtomicUsize::new(0); + let done: Mutex)>> = Mutex::new(Vec::new()); + let failure: Mutex> = Mutex::new(None); + std::thread::scope(|s| { + for _ in 0..workers { + s.spawn(|| { + loop { + if failure.lock().unwrap().is_some() { + break; + } + // Pop and the in-flight increment are ATOMIC under the queue + // lock: a worker that sees the queue empty is then guaranteed a + // consistent in-flight read — the last popper has already + // registered. (Split, the window between pop and increment let + // idle workers read `empty && in_flight == 0` and exit while + // work remained; the fleet silently drained.) + let next = { + let mut q = queue.lock().unwrap(); + let popped = q.pop_front(); + if popped.is_some() { + in_flight.fetch_add(1, Ordering::AcqRel); + } + popped + }; + let Some((origin, seq, range)) = next else { + // Empty queue but ranges in flight may still re-queue + // remainders; only quit when nothing can produce more work. + if in_flight.load(Ordering::Acquire) == 0 { + break; + } + std::thread::sleep(std::time::Duration::from_millis(50)); + continue; + }; + match scan_range(&ctx, &range, origin) { + Ok((segs, rest)) => { + done.lock().unwrap().push(((origin, seq), segs)); + // Remainder goes back BEFORE the in-flight decrement, so + // `empty && in_flight == 0` still implies no future work. + if !rest.is_empty() { + queue.lock().unwrap().push_back((origin, seq + 1, rest)); + } + }, + Err(e) => { + ctx.abort.store(true, Ordering::Release); + let mut f = failure.lock().unwrap(); + if f.is_none() { + *f = Some(e); + } + }, + } + in_flight.fetch_sub(1, Ordering::AcqRel); + } + }); + } + }); + if let Some(e) = failure.into_inner().unwrap() { + return Err(e); + } + let mut tagged = done.into_inner().unwrap(); + tagged.sort_by_key(|(k, _)| *k); + let mut segments: Vec = Vec::new(); + for (_, mut segs) in tagged { + segments.append(&mut segs); + } + + // Merge + re-measure to a fixpoint. Merging by FFT sum is always safe + // (the union's real cost is ≤ the sum: shared deps derive once) but the + // sum badly overstates a shard assembled from many cold mini-segments — + // each paid its own frontier unfolding. So every merged shard is + // re-measured with ONE cold thin-frontier CheckEnv (exactly the claim + // proving pays), and merging reruns with true costs until nothing + // merges. This is what lets the chunk count scale with workers without + // fragmenting the pack or corrupting the cost sidecar. + let pre_merge = segments.len(); + // EVERY segment starts dirty: the incremental scan's running readout + // carries per-block claim inflation (env_walk re-runs per claim), so + // each shard is re-priced once with the single cold thin-frontier + // CheckEnv a prove of it actually executes. Merging then compares true + // costs — without this, inflated sums block consolidation and the + // sidecar over-states prove RSS. (Re-measures run `workers`-wide; a + // shard's record is bounded by the cut, so the fleet bound holds.) + let mut list: Vec<(Segment, bool)> = + segments.into_iter().map(|s| (s, true)).collect(); + for round in 0usize.. { + let used = + |sg: &Segment| AIUR_RAM_GIB_PER_BFFT * sg.fft / 1e9 + sg.bytes_gib; + let mut merged: Vec<(Segment, bool)> = Vec::new(); + for (seg, dirty) in list { + match merged.last_mut() { + Some((prev, prev_dirty)) if used(prev) + used(&seg) < cut_used_gib => { + prev.blocks.extend(seg.blocks); + prev.fft += seg.fft; + prev.bytes_gib += seg.bytes_gib; + *prev_dirty = true; + }, + _ => merged.push((seg, dirty)), + } + } + list = merged; + let dirty_idx: Vec = list + .iter() + .enumerate() + .filter_map(|(i, (_, d))| d.then_some(i)) + .collect(); + if dirty_idx.is_empty() { + break; + } + if round >= 3 { + // Leftover sums are conservative (over-budget never happens); stop + // refining rather than loop on a pathological pack. + eprintln!( + "[scan] {} shard(s) keep conservative summed costs after {round} \ + refine rounds", + dirty_idx.len() + ); + break; + } + eprintln!( + "[scan] refine round {round}: re-measuring {} merged shard(s)", + dirty_idx.len() + ); + let re_cursor = AtomicUsize::new(0); + let re_results: Mutex>>> = + Mutex::new((0..dirty_idx.len()).map(|_| None).collect()); + std::thread::scope(|s| { + for _ in 0..workers.min(dirty_idx.len()) { + s.spawn(|| { + loop { + let j = re_cursor.fetch_add(1, Ordering::Relaxed); + if j >= dirty_idx.len() { + break; + } + let out = measure_shard(&ctx, &list[dirty_idx[j]].0.blocks); + re_results.lock().unwrap()[j] = Some(out); + } + }); + } + }); + for (j, slot) in re_results.into_inner().unwrap().into_iter().enumerate() { + let (seg, dirty) = &mut list[dirty_idx[j]]; + match slot { + Some(Ok((fft, bytes_gib))) => { + seg.fft = fft; + seg.bytes_gib = bytes_gib; + }, + Some(Err(e)) if !fail_fast => { + // The conservative fft SUM stands for this shard. + eprintln!( + "[scan] re-measure of shard {j} failed ({e}); keeping \ + the summed cost" + ); + }, + Some(Err(e)) => return Err(format!("re-measure shard {j}: {e}")), + None => return Err(format!("re-measure shard {j}: never ran")), + } + *dirty = false; + } + } + let segments: Vec = list.into_iter().map(|(s, _)| s).collect(); + + // Manifest: owned blocks per segment; frontier fields are the claim + // layer's business (reconstructed from env + owned at check/prove time). + let num = segments.len(); + let mut infos = Vec::with_capacity(num); + for (id, seg) in segments.iter().enumerate() { + let mut addrs: Vec
= + seg.blocks.iter().map(|&b| blocks[b as usize].addr.clone()).collect(); + addrs.sort(); + let own_size: u64 = + seg.blocks.iter().map(|&b| blocks[b as usize].size).sum(); + infos.push(ShardInfo { + id: u32::try_from(id).expect("shard count exceeds u32"), + blocks: addrs, + cost: ShardCost::AiurFft(cost_fft(seg.fft)), + own_size, + foreign_blocks: Vec::new(), + cross_ingress: 0, + assumption_root: None, + }); + } + let num_u32 = u32::try_from(num).expect("shard count exceeds u32"); + let manifest = ShardManifest { + num_shards: num_u32, + shards: infos, + total_cross_ingress: 0, + tree: Some(balanced_agg_tree(0, num_u32)), + }; + std::fs::write(out_path, manifest.to_bytes()) + .map_err(|e| format!("write {out_path}: {e}"))?; + + // Costs sidecar: MEASURED fft per shard mapped through the calibrated + // resource lines — same header the batch prove driver's heaviest-first + // ordering reads; the counter columns are zero (nothing was predicted). + let mut csv = String::from( + "shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,\ + pred_ram_gib,pred_prove_s\n", + ); + let mut max_ram = 0.0f64; + let mut over = 0usize; + for (id, seg) in segments.iter().enumerate() { + let own: u64 = seg.blocks.iter().map(|&b| blocks[b as usize].size).sum(); + // Predicted prove RSS = the fft resource line PLUS the measured + // record bytes the prove's execute replays into — the second term is + // what the fitted line missed on arithmetic-heavy shards. + let ram = aiur_ram_gib_for_fft(seg.fft) + seg.bytes_gib; + csv.push_str(&format!( + "{},{},0,0,0,0,0,0,{:.2},{:.2}\n", + id, + own, + ram, + aiur_prove_secs_for_fft(seg.fft), + )); + max_ram = max_ram.max(ram); + let used = AIUR_RAM_GIB_PER_BFFT * seg.fft / 1e9 + seg.bytes_gib; + if used >= cut_used_gib / (1.0 - eps) { + over += 1; + } + } + let cp = format!("{out_path}.costs.csv"); + std::fs::write(&cp, csv).map_err(|e| format!("write {cp}: {e}"))?; + + let mut note = if over > 0 { + format!( + "\n [{over} single-block segment(s) exceed the cap alone — atomically \ + infeasible at this budget]" + ) + } else { + String::new() + }; + let failed = failed.into_inner().unwrap(); + if !failed.is_empty() { + let mut fcsv = String::from("block,error\n"); + for (a, e) in &failed { + fcsv.push_str(&format!( + "{},{}\n", + a.hex(), + e.replace('\n', " ").replace(',', ";") + )); + } + let fp = format!("{out_path}.failed.csv"); + std::fs::write(&fp, fcsv).map_err(|e| format!("write {fp}: {e}"))?; + note.push_str(&format!( + "\n [{} kernel-rejected block(s) SKIPPED — the partition does NOT \ + cover them (the coverage gate will name them); see {fp}]", + failed.len() + )); + } + Ok(format!( + "scan: {} blocks in {} chunks → {num} shards ({pre_merge} pre-merge) @ \ + {budget_gib:.0} GiB (cut at {:.1} GiB combined, ε {:.0}%)\nmax \ + predicted prove RSS {max_ram:.1} GiB (fft line + measured record \ + bytes){note}", + blocks.len(), + chunks.len(), + cut_used_gib, + eps * 100.0, + )) +} + +/// Measure one shard's true cold cost: a single thin-frontier `CheckEnv` +/// over its blocks against a fresh record and lazily-faulted witness — +/// the exact execution a prove of this shard performs. +fn measure_shard( + ctx: &ScanCtx<'_>, + block_ids: &[u32], +) -> Result<(f64, f64), String> { + let owned: Vec
= + block_ids.iter().map(|&b| ctx.blocks[b as usize].addr.clone()).collect(); + let mut record = QueryRecord::new(ctx.toplevel); + let mut io = IOBuffer::with_backing(EnvFaultSource::new(ctx.env.clone())); + let (_claim, input) = seed_shard_check_env_claim(ctx.env, &owned, &mut io)?; + execute_ixvm_with_record( + ctx.toplevel, + ctx.fun_idx, + &input, + &mut io, + &mut record, + ) + .map_err(|e| format!("re-measure CheckEnv failed: {e}"))?; + Ok(( + record_fft_cost(ctx.toplevel, &record), + f64_from_usize(record_retained_bytes(&record)) / GIB, + )) +} + +/// Number of segments one work-range yields before its remainder goes +/// back on the queue for any idle worker. +const RANGE_SEGMENTS: usize = 2; + +/// Scan one range: execute per-block thin-frontier `CheckEnv` claims +/// against a shared record and lazily-faulted witness, checkpointing the +/// running FFT after every block and cutting on the exact block boundary +/// where it reaches the cut (the crossing block re-executes as the next +/// segment's first block, so an emitted shard never exceeds the cut — +/// except a single atomically-infeasible block, emitted alone with its +/// measured cost). One claim per block costs ~1ms of plumbing (measured) +/// plus a small per-block assumption-tree inflation that only steers cut +/// placement — the merge + re-measure pass re-prices every shard with +/// ONE real claim — and in exchange the scan is preemptible at BLOCK +/// granularity: no growth attempts, no overshoot re-execution, no cold +/// restarts, and RAM shedding or work-stealing acts between any two +/// blocks instead of stalling behind a multi-minute claim execution. +/// Emits at most [`RANGE_SEGMENTS`] segments, then returns the remaining +/// blocks for any idle worker. +fn scan_range( + ctx: &ScanCtx<'_>, + chunk: &[u32], + origin: u32, +) -> Result<(Vec, Vec), String> { + let t0 = std::time::Instant::now(); + let chunk_id = origin; + let n_chunks = ctx.n_chunks; + let mut segments: Vec = Vec::new(); + let mut lo = 0usize; + while lo < chunk.len() && segments.len() < RANGE_SEGMENTS { + let mut record = QueryRecord::new(ctx.toplevel); + // Arm the per-worker record cap for this fresh record. Worker threads + // run nothing but scan ranges, and arming resets the charge counter, + // so per-segment arming with no disarm is sufficient. + set_record_byte_budget(ctx.seg_byte_budget); + let mut io = IOBuffer::with_backing(EnvFaultSource::new(ctx.env.clone())); + let mut prev_fft = 0.0f64; + let mut prev_bytes = 0.0f64; + let mut hi = lo; + let mut skip_failed = false; + let (seg_end, seg_fft, seg_bytes) = loop { + if hi >= chunk.len() { + break (hi, prev_fft, prev_bytes); + } + if ctx.abort.load(Ordering::Acquire) { + return Err("aborted after a failure elsewhere".to_string()); + } + let addr = ctx.blocks[chunk[hi] as usize].addr.clone(); + // `Err(None)` = the record cap tripped mid-block (not a kernel + // verdict); `Err(Some(e))` = the kernel rejected the block. + let out: Result<(), Option> = seed_shard_check_env_claim( + ctx.env, + std::slice::from_ref(&addr), + &mut io, + ) + .map_err(Some) + .and_then(|(_claim, input)| { + execute_ixvm_with_record( + ctx.toplevel, + ctx.fun_idx, + &input, + &mut io, + &mut record, + ) + .map(|_| ()) + .map_err(|e| match e { + ExecError::RecordBudgetExceeded => None, + other => Some(other.to_string()), + }) + }); + // A cap trip on a segment that already holds blocks is an early + // cut, not a failure: cut at the previous block; the crossing + // block restarts the next segment with a fresh record and full + // cap, and only counts as over-cap if it then trips ALONE. + if matches!(out, Err(None)) && hi > lo { + break (hi, prev_fft, prev_bytes); + } + if let Err(err) = out { + let e = err.unwrap_or_else(|| { + format!( + "record bytes crossed the {:.1} GiB per-worker cap alone — \ + resource-infeasible at this box share (--workers 1 grants \ + the whole allowance)", + f64_from_usize(ctx.seg_byte_budget) / GIB + ) + }); + if ctx.fail_fast { + return Err(format!( + "CheckEnv of block {} failed during scan: {e} \ + (--no-fail-fast records and skips such blocks)", + addr.hex() + )); + } + // No fail-fast: name the block NOW, drop it from the partition, + // and emit the running segment so the failed execution's partial + // rows cannot pollute later measurements (fresh record). + eprintln!( + "[scan {chunk_id}/{n_chunks}] SKIPPING block {}: {e}", + addr.hex() + ); + ctx.failed.lock().unwrap().push((addr, e)); + skip_failed = true; + break (hi, prev_fft, prev_bytes); + } + let fft = record_fft_cost(ctx.toplevel, &record); + let bytes_gib = f64_from_usize(record_retained_bytes(&record)) / GIB; + let used = AIUR_RAM_GIB_PER_BFFT * fft / 1e9 + bytes_gib; + if used >= ctx.cut_used_gib { + if hi == lo { + // A single block alone reaches the cut: atomically infeasible + // at this budget — emitted alone with its measured cost. + break (hi + 1, fft, bytes_gib); + } + break (hi, prev_fft, prev_bytes); + } + hi += 1; + prev_fft = fft; + prev_bytes = bytes_gib; + }; + if query_stats_enabled() { + dump_query_stats(&record, &format!("scan {chunk_id} seg")); + } + // A failure on a segment's FIRST block leaves nothing to emit; the + // failed block itself is skipped either way (`skip_failed`). + if seg_end > lo { + // Memory decomposition per segment: witness arena G-elements, io + // map entries, record entries — with process RSS, these split the + // footprint into decode-cache baseline / live worker data / + // unaccounted, so a single run localizes any growth. + let arena_g: usize = io.data.values().map(Vec::len).sum(); + let rec_e: usize = + record.function_queries.iter().map(|m| m.len()).sum::() + + record.memory_queries.iter().map(|(_, m)| m.len()).sum::(); + eprintln!( + "[scan {chunk_id}/{n_chunks}] segment: {} blocks, {:.2} BFFT + \ + {:.1}G rec, {}/{} blocks done, {:.0}s, rss {:.0}G, arena {}M, \ + iomap {}k, rec {}M", + seg_end - lo, + seg_fft / 1e9, + seg_bytes, + seg_end, + chunk.len(), + t0.elapsed().as_secs_f64(), + process_rss_gib(), + arena_g / 1_000_000, + io.map.len() / 1000, + rec_e / 1_000_000 + ); + segments.push(Segment { + blocks: chunk[lo..seg_end].to_vec(), + fft: seg_fft, + bytes_gib: seg_bytes, + }); + } + lo = seg_end + usize::from(skip_failed); + } + if lo >= chunk.len() { + eprintln!( + "[scan {chunk_id}/{n_chunks}] range done: {} blocks → {} segment(s), \ + {:.0}s", + chunk.len(), + segments.len(), + t0.elapsed().as_secs_f64() + ); + } + Ok((segments, chunk[lo..].to_vec())) +} + +use lean_ffi::object::{ + LeanBorrowed, LeanExcept, LeanExternal, LeanNat, LeanOwned, LeanString, +}; + +use crate::aiur::toplevel::decode_toplevel; +use crate::lean::LeanAiurToplevel; + +/// `Bytecode.Toplevel.scanShardsWithEnv`: scan-and-cut sharding against a +/// Rust-owned `EnvHandle`. Numeric params are decimal strings (ABI-simple): +/// `budget_gib` (RAM budget per shard, GiB), `eps_pct` (pre-charged cut +/// headroom, percent), `workers` (parallel chunk scanners; `0` autoscales +/// to cores and detected RAM — each worker holds one segment's QueryRecord +/// and faulted witness). Writes `out_path` (.ixes) plus its `.costs.csv` +/// sidecar carrying the MEASURED per-shard FFT mapped through the +/// calibrated resource lines. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_scan_shards_with_env( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + env_handle: LeanExternal< + ixvm_codegen::env_handle::EnvHandle, + LeanBorrowed<'_>, + >, + budget_gib: LeanString>, + eps_pct: LeanString>, + workers: LeanString>, + fail_fast: LeanString>, + out_path: LeanString>, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = crate::aiur::lean_unbox_nat_as_usize(fun_idx.inner()); + let budget = budget_gib.to_string().parse::().unwrap_or(0.0); + if budget <= 0.0 { + return LeanExcept::error_string("scan: pass a positive RAM budget (GiB)"); + } + let eps = eps_pct.to_string().parse::().unwrap_or(5.0) / 100.0; + let workers = workers.to_string().parse::().unwrap_or(0); + let fail_fast = fail_fast.to_string() != "0"; + match scan_shards( + &toplevel, + fun_idx, + &env_handle.get().env, + budget, + eps, + workers, + fail_fast, + &out_path.to_string(), + ) { + Ok(report) => { + eprintln!("[rs_scan]\n{report}"); + LeanExcept::ok(LeanOwned::box_usize(0)) + }, + Err(e) => LeanExcept::error_string(&format!("rs_aiur_scan_shards: {e}")), + } +} diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index ce5a92eed..610695f41 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -3103,7 +3103,7 @@ pub extern "C" fn rs_shard_esp( } /// Total system RAM in GiB from `/proc/meminfo` (Linux); `None` if unreadable. -fn system_ram_gib() -> Option { +pub(crate) fn system_ram_gib() -> Option { let s = std::fs::read_to_string("/proc/meminfo").ok()?; let rest = s.lines().find_map(|l| l.strip_prefix("MemTotal:"))?; let kib: f64 = rest.trim().trim_end_matches("kB").trim().parse().ok()?; diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index fd884107c..18eb72588 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -14,7 +14,7 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; -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_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; +use aiur::execute::{ ExecError, IOBuffer, QueryRecord, record_budget_exceeded, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_and_value, bytes2_or_value, bytes2_less_than_value, bytes2_add_value, bytes2_sub_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; @@ -268,12 +268,14 @@ fn aiur_fn_0( let __v_227: G = G::from_u64(1); let __ret: [G; OUT_0] = [__v_227]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_227: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_227]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -282,6 +284,7 @@ fn aiur_fn_0( let __v_214: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_214]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -290,6 +293,7 @@ fn aiur_fn_0( let __v_177: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_177]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -298,6 +302,7 @@ fn aiur_fn_0( let __v_140: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_140]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -306,6 +311,7 @@ fn aiur_fn_0( let __v_103: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_103]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -397,12 +403,14 @@ fn aiur_fn_1( let __v_67: G = __r_arr[0]; let __ret: [G; OUT_1] = [__v_67]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_67]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -426,9 +434,10 @@ fn aiur_fn_2( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_2] = [__v_5]; record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -441,9 +450,10 @@ fn aiur_fn_2( let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_2] = [__v_10]; record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -485,12 +495,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -501,12 +513,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -521,12 +535,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -537,12 +553,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -561,12 +579,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -577,12 +597,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -597,12 +619,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -613,12 +637,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -641,12 +667,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -657,12 +685,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -677,12 +707,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -693,12 +725,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -717,12 +751,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -733,12 +769,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -753,12 +791,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -769,12 +809,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -801,12 +843,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(3); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -817,12 +861,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -837,12 +883,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -853,12 +901,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -877,12 +927,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -893,12 +945,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -913,12 +967,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -929,12 +985,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -957,12 +1015,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -973,12 +1033,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -993,12 +1055,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1009,12 +1073,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1033,12 +1099,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1049,12 +1117,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1069,12 +1139,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1085,12 +1157,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1121,12 +1195,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1137,12 +1213,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1157,12 +1235,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1173,12 +1253,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1197,12 +1279,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1213,12 +1297,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1233,12 +1319,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1249,12 +1337,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1277,12 +1367,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1293,12 +1385,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1313,12 +1407,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1329,12 +1425,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1353,12 +1451,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1369,12 +1469,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1389,12 +1491,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1405,12 +1509,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1437,12 +1543,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(3); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1453,12 +1561,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1473,12 +1583,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1489,12 +1601,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1513,12 +1627,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1529,12 +1645,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1549,12 +1667,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1565,12 +1685,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1593,12 +1715,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1609,12 +1733,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1629,12 +1755,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1645,12 +1773,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1669,12 +1799,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1685,12 +1817,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1705,12 +1839,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1721,12 +1857,14 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1782,12 +1920,14 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1796,6 +1936,7 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1804,6 +1945,7 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1812,6 +1954,7 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1820,6 +1963,7 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1828,6 +1972,7 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1836,6 +1981,7 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1844,6 +1990,7 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1893,6 +2040,7 @@ fn aiur_fn_5( let __v_23: G = __b2_add.1; let __ret: [G; OUT_5] = [__v_8, __v_12, __v_17, __v_22]; record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1921,6 +2069,7 @@ fn aiur_fn_6( let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1941,6 +2090,7 @@ fn aiur_fn_7( let __v_3: G = inp[3]; let __ret: [G; OUT_7] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1961,6 +2111,7 @@ fn aiur_fn_8( let __v_3: G = inp[3]; let __ret: [G; OUT_8] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1991,6 +2142,7 @@ fn aiur_fn_9( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_9] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2021,6 +2173,7 @@ fn aiur_fn_10( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_10] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2078,12 +2231,14 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(1); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2092,6 +2247,7 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2100,6 +2256,7 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2108,6 +2265,7 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2116,6 +2274,7 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2124,6 +2283,7 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2132,6 +2292,7 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2140,6 +2301,7 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2226,6 +2388,7 @@ fn aiur_fn_12( let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_12] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2274,6 +2437,7 @@ fn aiur_fn_13( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2288,6 +2452,7 @@ fn aiur_fn_13( let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2303,6 +2468,7 @@ fn aiur_fn_13( let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2317,6 +2483,7 @@ fn aiur_fn_13( let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2330,6 +2497,7 @@ fn aiur_fn_13( let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2342,6 +2510,7 @@ fn aiur_fn_13( let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2353,6 +2522,7 @@ fn aiur_fn_13( let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2363,6 +2533,7 @@ fn aiur_fn_13( let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2372,6 +2543,7 @@ fn aiur_fn_13( let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2422,6 +2594,7 @@ fn aiur_fn_14( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2436,6 +2609,7 @@ fn aiur_fn_14( let __v_16: G = (__v_7 - __v_15); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2451,6 +2625,7 @@ fn aiur_fn_14( let __v_15: G = (__v_6 - __v_14); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2465,6 +2640,7 @@ fn aiur_fn_14( let __v_14: G = (__v_5 - __v_13); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2478,6 +2654,7 @@ fn aiur_fn_14( let __v_13: G = (__v_4 - __v_12); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2490,6 +2667,7 @@ fn aiur_fn_14( let __v_12: G = (__v_3 - __v_11); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2501,6 +2679,7 @@ fn aiur_fn_14( let __v_11: G = (__v_2 - __v_10); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2511,6 +2690,7 @@ fn aiur_fn_14( let __v_10: G = (__v_1 - __v_9); let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2520,6 +2700,7 @@ fn aiur_fn_14( let __v_9: G = (__v_0 - __v_8); let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2568,6 +2749,7 @@ fn aiur_fn_15( let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_15] = [__v_26]; record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2617,7 +2799,7 @@ fn aiur_fn_16( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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); @@ -2628,11 +2810,11 @@ fn aiur_fn_16( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -2705,6 +2887,7 @@ fn aiur_fn_16( let __v_117: G = __r_arr[31]; let __ret: [G; OUT_16] = [__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]; record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2883,6 +3066,7 @@ fn aiur_fn_17( } let __ret: [G; OUT_17] = []; record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2931,9 +3115,10 @@ fn aiur_fn_18( let __v_30: G = __r_arr[29]; let __v_31: G = __r_arr[30]; let __v_32: G = __r_arr[31]; - let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_18] = [__v_33]; record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -3022,6 +3207,7 @@ fn aiur_fn_19( let __v_69: G = G::from_u64(1); let __ret: [G; OUT_19] = [__v_67, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -3134,6 +3320,7 @@ fn aiur_fn_19( let __v_169: G = G::from_u64(1); let __ret: [G; OUT_19] = [__v_169, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -3220,9 +3407,10 @@ fn aiur_fn_19( let __v_246: G = G::from_u64(0); let __v_247: G = G::from_u64(0); let __v_248: G = G::from_u64(0); - let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_19] = [__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_248, __v_249, __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, __v_242, __v_243, __v_244, __v_245]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3271,9 +3459,10 @@ fn aiur_fn_19( let __v_244: G = G::from_u64(0); let __v_245: G = G::from_u64(0); let __v_246: G = G::from_u64(0); - let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_19] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __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, __v_242, __v_243]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -3375,6 +3564,7 @@ fn aiur_fn_20( 1u64 => { let __ret: [G; OUT_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_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3519,11 +3709,12 @@ fn aiur_fn_20( let __v_201: G = __r_arr[31]; let __ret: [G; OUT_20] = [__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, __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]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_170: G = G::from_u64(0); - let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_170, __v_171, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; @@ -3559,6 +3750,7 @@ fn aiur_fn_20( let __v_203: G = __r_arr[31]; let __ret: [G; OUT_20] = [__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, __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]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3602,17 +3794,19 @@ fn aiur_fn_21( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_21] = [__v_10]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_21] = [__v_12]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3624,6 +3818,7 @@ fn aiur_fn_21( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_21] = [__v_16]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4032,6 +4227,7 @@ fn aiur_fn_22( 0u64 => { let __ret: [G; OUT_22] = [__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[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -4372,18 +4568,20 @@ fn aiur_fn_23( 0u64 => { let __ret: [G; OUT_23] = [__v_0]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_23] = [__v_7]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4581,14 +4779,16 @@ fn aiur_fn_24( let __v_154: G = __r_arr[29]; let __v_155: G = __r_arr[30]; let __v_156: G = __r_arr[31]; - let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_24] = [__v_157]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4596,6 +4796,7 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4603,6 +4804,7 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4610,6 +4812,7 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4617,6 +4820,7 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4624,6 +4828,7 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4631,6 +4836,7 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4638,6 +4844,7 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4677,9 +4884,10 @@ fn aiur_fn_24( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_24] = [__v_42]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4847,9 +5055,10 @@ fn aiur_fn_24( let __v_161: G = __r_arr[29]; let __v_162: G = __r_arr[30]; let __v_163: G = __r_arr[31]; - let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_24] = [__v_164]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4942,7 +5151,7 @@ fn aiur_fn_25( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; @@ -5067,10 +5276,10 @@ fn aiur_fn_25( let __v_189: G = __r_arr[29]; let __v_190: G = __r_arr[30]; let __v_191: G = __r_arr[31]; - let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_193: G = G::from_u64(1); let __v_194: G = G::from_u64(1); - let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_196: G = G::from_u64(0); let __v_197: G = G::from_u64(0); let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; @@ -5091,19 +5300,20 @@ fn aiur_fn_25( let __v_211: G = __r_arr[5]; let __v_212: G = __r_arr[6]; let __v_213: G = __r_arr[7]; - let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_216: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_216]; record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; @@ -5202,15 +5412,16 @@ fn aiur_fn_25( let __v_165: G = __r_arr[31]; let __v_166: G = G::from_u64(1); let __v_167: G = G::from_u64(1); - let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_169: G = G::from_u64(0); let __v_170: G = G::from_u64(1); let __v_171: G = (__v_2 + __v_170); - let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_173: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_173]; record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -5427,6 +5638,7 @@ fn aiur_fn_26( let __v_151: G = (__v_148 + __v_146); let __ret: [G; OUT_26] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120]; record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -5707,6 +5919,7 @@ fn aiur_fn_27( let __v_255: G = __r_arr[15]; let __ret: [G; OUT_27] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __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[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6786,6 +6999,7 @@ fn aiur_fn_28( let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) }; let __ret: [G; OUT_28] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055]; record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6826,6 +7040,7 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -6834,10 +7049,11 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -6855,10 +7071,11 @@ fn aiur_fn_29( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_30]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -6876,6 +7093,7 @@ fn aiur_fn_29( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_30]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -6907,6 +7125,7 @@ fn aiur_fn_29( let __v_40: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_40]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -6915,6 +7134,7 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -6923,6 +7143,7 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -6942,6 +7163,7 @@ fn aiur_fn_29( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_29]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -6961,6 +7183,7 @@ fn aiur_fn_29( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_29]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -6980,6 +7203,7 @@ fn aiur_fn_29( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_29]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -7051,6 +7275,7 @@ fn aiur_fn_29( let __v_77: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_77]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { @@ -7059,6 +7284,7 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7092,6 +7318,7 @@ fn aiur_fn_30( 0u64 => { let __ret: [G; OUT_30] = [__v_9]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7101,9 +7328,10 @@ fn aiur_fn_30( let __v_13: G = (__v_8 - __v_12); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_30] = [__v_15]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7138,9 +7366,10 @@ fn aiur_fn_31( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_31] = [__v_13]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7151,9 +7380,10 @@ fn aiur_fn_31( let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_31] = [__v_18]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7166,9 +7396,10 @@ fn aiur_fn_31( let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_31] = [__v_18]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7207,9 +7438,10 @@ fn aiur_fn_32( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_32] = [__v_17]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7223,9 +7455,10 @@ fn aiur_fn_32( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_32] = [__v_22]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7241,9 +7474,10 @@ fn aiur_fn_32( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_32] = [__v_22]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7282,9 +7516,10 @@ fn aiur_fn_33( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_33] = [__v_17]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7298,9 +7533,10 @@ fn aiur_fn_33( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_33] = [__v_22]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7316,9 +7552,10 @@ fn aiur_fn_33( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_33] = [__v_22]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7352,6 +7589,7 @@ fn aiur_fn_34( 1u64 => { let __ret: [G; OUT_34] = [__v_1]; record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -7361,6 +7599,7 @@ fn aiur_fn_34( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_13]; record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7439,6 +7678,7 @@ fn aiur_fn_35( let __v_51: G = __r_arr[7]; let __ret: [G; OUT_35] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7452,6 +7692,7 @@ fn aiur_fn_35( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7527,6 +7768,7 @@ fn aiur_fn_36( let __v_51: G = __r_arr[7]; let __ret: [G; OUT_36] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7540,6 +7782,7 @@ fn aiur_fn_36( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7615,6 +7858,7 @@ fn aiur_fn_37( let __v_51: G = __r_arr[7]; let __ret: [G; OUT_37] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7628,6 +7872,7 @@ fn aiur_fn_37( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_37] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7709,6 +7954,7 @@ fn aiur_fn_38( let __v_56: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_56]; record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7716,6 +7962,7 @@ fn aiur_fn_38( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_19]; record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7797,6 +8044,7 @@ fn aiur_fn_39( let __v_56: G = __r_arr[0]; let __ret: [G; OUT_39] = [__v_56]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7804,6 +8052,7 @@ fn aiur_fn_39( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_39] = [__v_19]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7885,6 +8134,7 @@ fn aiur_fn_40( let __v_56: G = __r_arr[0]; let __ret: [G; OUT_40] = [__v_56]; record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7892,6 +8142,7 @@ fn aiur_fn_40( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_40] = [__v_19]; record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7944,71 +8195,72 @@ fn aiur_fn_41( let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_50: G = G::from_u64(0); - let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_54: G = G::from_u64(0); - let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_56: G = G::from_u64(0); - let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_60: G = G::from_u64(0); - let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_62: G = G::from_u64(0); - let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_68: G = G::from_u64(0); - let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_70: G = G::from_u64(0); - let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_72: G = G::from_u64(0); - let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_74: G = G::from_u64(0); - let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_76: G = G::from_u64(0); - let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_78: G = G::from_u64(0); - let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_80: G = G::from_u64(0); - let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_82: G = G::from_u64(0); - let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_84: G = G::from_u64(0); - let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_86: G = G::from_u64(0); - let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_88: G = G::from_u64(0); - let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_90: G = G::from_u64(0); - let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_92: G = G::from_u64(0); - let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_94: G = G::from_u64(0); - let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_96: G = G::from_u64(0); - let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_41] = [__v_97]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8032,18 +8284,21 @@ fn aiur_fn_42( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8057,18 +8312,21 @@ fn aiur_fn_42( let __v_2: G = G::from_u64(4); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8082,18 +8340,21 @@ fn aiur_fn_42( let __v_2: G = G::from_u64(8); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8159,6 +8420,7 @@ fn aiur_fn_43( let __v_33: G = __r_arr[7]; let __ret: [G; OUT_43] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8172,6 +8434,7 @@ fn aiur_fn_43( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_43] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8221,11 +8484,13 @@ fn aiur_fn_44( let __v_26: G = __r_arr[8]; let __ret: [G; OUT_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8256,9 +8521,10 @@ fn aiur_fn_45( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_45] = [__v_12]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -8288,6 +8554,7 @@ fn aiur_fn_45( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_29]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -8328,6 +8595,7 @@ fn aiur_fn_45( let __v_39: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_39]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -8368,6 +8636,7 @@ fn aiur_fn_45( let __v_39: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_39]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -8376,6 +8645,7 @@ fn aiur_fn_45( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_11]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8405,6 +8675,7 @@ fn aiur_fn_46( 1u64 => { let __ret: [G; OUT_46] = [__v_1]; record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8433,6 +8704,7 @@ fn aiur_fn_46( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_46] = [__v_24]; record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8462,6 +8734,7 @@ fn aiur_fn_47( 1u64 => { let __ret: [G; OUT_47] = [__v_1]; record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8481,6 +8754,7 @@ fn aiur_fn_47( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_47] = [__v_15]; record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8510,6 +8784,7 @@ fn aiur_fn_48( 1u64 => { let __ret: [G; OUT_48] = [__v_1]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8519,6 +8794,7 @@ fn aiur_fn_48( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_48] = [__v_6]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8544,33 +8820,37 @@ fn aiur_fn_49( 0u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(3); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8652,9 +8932,10 @@ fn aiur_fn_50( let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_50] = [__v_54]; record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8708,6 +8989,7 @@ fn aiur_fn_51( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_29]; record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8742,6 +9024,7 @@ fn aiur_fn_52( 1u64 => { let __ret: [G; OUT_52] = [__v_1]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8751,6 +9034,7 @@ fn aiur_fn_52( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_14]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8839,7 +9123,7 @@ fn aiur_fn_53( 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_724] = { let __args: [G; IN_724] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -8865,9 +9149,10 @@ fn aiur_fn_53( let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_53] = [__v_83]; record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8921,9 +9206,10 @@ fn aiur_fn_54( let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_54] = [__v_32]; record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8980,6 +9266,7 @@ fn aiur_fn_55( let __v_31: G = __r_arr[0]; let __ret: [G; OUT_55] = [__v_31]; record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9063,9 +9350,10 @@ fn aiur_fn_56( let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_56] = [__v_59]; record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9125,6 +9413,7 @@ fn aiur_fn_57( 1u64 => { let __ret: [G; OUT_57] = [__v_1]; record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9134,6 +9423,7 @@ fn aiur_fn_57( let __v_39: G = __r_arr[0]; let __ret: [G; OUT_57] = [__v_39]; record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9202,7 +9492,7 @@ fn aiur_fn_58( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -9224,9 +9514,10 @@ fn aiur_fn_58( let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_58] = [__v_61]; record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9261,6 +9552,7 @@ fn aiur_fn_59( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_59] = [__v_11]; record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9305,6 +9597,7 @@ fn aiur_fn_60( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_20]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9373,9 +9666,10 @@ fn aiur_fn_61( let __v_47: G = G::from_u64(0); let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_61] = [__v_49]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -9383,9 +9677,10 @@ fn aiur_fn_61( let __v_47: G = G::from_u64(1); let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_61] = [__v_49]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -9393,9 +9688,10 @@ fn aiur_fn_61( let __v_47: G = G::from_u64(2); let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_61] = [__v_49]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9469,6 +9765,7 @@ fn aiur_fn_62( 1u64 => { let __ret: [G; OUT_62] = [__v_1]; record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9478,6 +9775,7 @@ fn aiur_fn_62( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_62] = [__v_50]; record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9549,6 +9847,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -9556,6 +9855,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -9563,6 +9863,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -9570,6 +9871,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -9577,6 +9879,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -9584,6 +9887,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -9591,6 +9895,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -9598,6 +9903,7 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9619,7 +9925,7 @@ fn aiur_fn_64( 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_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9634,6 +9940,7 @@ fn aiur_fn_64( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_64] = [__v_11]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -9650,7 +9957,7 @@ fn aiur_fn_65( 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_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9665,6 +9972,7 @@ fn aiur_fn_65( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_11]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -9681,7 +9989,7 @@ fn aiur_fn_66( 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_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9696,6 +10004,7 @@ fn aiur_fn_66( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_11]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -9769,7 +10078,7 @@ fn aiur_fn_67( let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -9785,6 +10094,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9803,6 +10113,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -9821,6 +10132,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -9839,6 +10151,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -9857,6 +10170,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -9875,6 +10189,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -9893,6 +10208,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -9911,6 +10227,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -9929,6 +10246,7 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9959,15 +10277,17 @@ fn aiur_fn_68( 0u64 => { let __ret: [G; OUT_68] = [__v_2, __v_3]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_68] = [__v_4, __v_7]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10001,6 +10321,7 @@ fn aiur_fn_69( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_69] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10024,6 +10345,7 @@ fn aiur_fn_69( let __v_15: G = __r_arr[8]; let __ret: [G; OUT_69] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10090,6 +10412,7 @@ fn aiur_fn_70( let __v_36: G = G::from_u64(0); let __ret: [G; OUT_70] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10113,6 +10436,7 @@ fn aiur_fn_70( let __v_43: G = __r_arr[8]; let __ret: [G; OUT_70] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10176,6 +10500,7 @@ fn aiur_fn_71( let __v_33: G = G::from_u64(0); let __ret: [G; OUT_71] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10199,6 +10524,7 @@ fn aiur_fn_71( } let __ret: [G; OUT_71] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10262,6 +10588,7 @@ fn aiur_fn_72( let __v_33: G = G::from_u64(0); let __ret: [G; OUT_72] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10279,6 +10606,7 @@ fn aiur_fn_72( let __v_37: G = __r_arr[8]; let __ret: [G; OUT_72] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10315,9 +10643,10 @@ fn aiur_fn_73( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_73] = [__v_12, __v_0]; record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10344,9 +10673,10 @@ fn aiur_fn_73( let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_73] = [__v_30, __v_28]; record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10382,6 +10712,7 @@ fn aiur_fn_74( 1u64 => { let __ret: [G; OUT_74] = [__v_0, __v_1]; record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10390,7 +10721,7 @@ fn aiur_fn_74( let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; @@ -10405,6 +10736,7 @@ fn aiur_fn_74( let __v_25: G = __r_arr[1]; let __ret: [G; OUT_74] = [__v_24, __v_25]; record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10442,6 +10774,7 @@ fn aiur_fn_75( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_75] = [__v_10, __v_11]; record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10462,9 +10795,10 @@ fn aiur_fn_75( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(8); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_75] = [__v_24, __v_21]; record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10502,6 +10836,7 @@ fn aiur_fn_76( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_76] = [__v_10, __v_11]; record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10522,9 +10857,10 @@ fn aiur_fn_76( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(9); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_76] = [__v_24, __v_21]; record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10560,17 +10896,19 @@ fn aiur_fn_77( 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -10589,9 +10927,10 @@ fn aiur_fn_77( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_24, __v_21]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -10610,9 +10949,10 @@ fn aiur_fn_77( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_24, __v_21]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -10630,25 +10970,28 @@ fn aiur_fn_77( let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(4); - let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_23, __v_21]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -10666,6 +11009,7 @@ fn aiur_fn_77( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_15, __v_16]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -10680,6 +11024,7 @@ fn aiur_fn_77( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_13, __v_14]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -10694,6 +11039,7 @@ fn aiur_fn_77( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_13, __v_14]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -10702,14 +11048,16 @@ fn aiur_fn_77( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_11, __v_12]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { let __v_11: G = G::from_u64(11); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10749,9 +11097,10 @@ fn aiur_fn_78( let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(10); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_78] = [__v_17, __v_14]; record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10789,6 +11138,7 @@ fn aiur_fn_79( 1u64 => { let __ret: [G; OUT_79] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10812,10 +11162,11 @@ fn aiur_fn_79( let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_37: G = G::from_u64(0); let __ret: [G; OUT_79] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10857,6 +11208,7 @@ fn aiur_fn_80( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10883,6 +11235,7 @@ fn aiur_fn_80( let __v_30: G = __r_arr[8]; let __ret: [G; OUT_80] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10914,11 +11267,12 @@ fn aiur_fn_80( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(2); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -10945,17 +11299,19 @@ fn aiur_fn_80( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(3); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11168,9 +11524,10 @@ fn aiur_fn_81( let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_81] = [__v_97, __v_96]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11360,9 +11717,10 @@ fn aiur_fn_82( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_82] = [__v_12, __v_0]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11382,9 +11740,10 @@ fn aiur_fn_82( let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_82] = [__v_23, __v_21]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11419,9 +11778,10 @@ fn aiur_fn_83( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_83] = [__v_12, __v_0]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11449,10 +11809,11 @@ fn aiur_fn_83( let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_83] = [__v_32, __v_29]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11487,9 +11848,10 @@ fn aiur_fn_84( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_84] = [__v_12, __v_0]; record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11509,9 +11871,10 @@ fn aiur_fn_84( let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_84] = [__v_23, __v_21]; record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11547,6 +11910,7 @@ fn aiur_fn_85( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_10, __v_11]; record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11577,6 +11941,7 @@ fn aiur_fn_86( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_86] = [__v_10, __v_11]; record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11607,6 +11972,7 @@ fn aiur_fn_87( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_87] = [__v_10, __v_11]; record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11628,6 +11994,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -11635,6 +12002,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -11642,6 +12010,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(2); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -11649,6 +12018,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -11656,6 +12026,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -11663,6 +12034,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(2); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -11670,6 +12042,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -11677,6 +12050,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -11684,6 +12058,7 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(2); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11728,6 +12103,7 @@ fn aiur_fn_89( let __v_17: G = __r_arr[1]; let __ret: [G; OUT_89] = [__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[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11758,6 +12134,7 @@ fn aiur_fn_90( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_90] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11787,9 +12164,10 @@ fn aiur_fn_91( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_91] = [__v_12, __v_0]; record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11817,9 +12195,10 @@ fn aiur_fn_91( 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; 11] = [__v_30, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_28]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 11] = [__v_30, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_28]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_91] = [__v_31, __v_29]; record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11920,6 +12299,7 @@ fn aiur_fn_92( let __v_68: G = __r_arr[1]; let __ret: [G; OUT_92] = [__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[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11943,6 +12323,7 @@ fn aiur_fn_93( } let __ret: [G; OUT_93] = []; record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11977,6 +12358,7 @@ fn aiur_fn_94( let __v_13: G = __r_arr[1]; let __ret: [G; OUT_94] = [__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[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11997,24 +12379,28 @@ fn aiur_fn_95( let __v_1: G = G::from_u64(0); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12055,6 +12441,7 @@ fn aiur_fn_96( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_96] = [__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[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12119,6 +12506,7 @@ fn aiur_fn_97( let __v_40: G = __r_arr[1]; let __ret: [G; OUT_97] = [__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[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12148,9 +12536,10 @@ fn aiur_fn_98( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_98] = [__v_12, __v_0]; record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12203,9 +12592,10 @@ fn aiur_fn_98( let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_98] = [__v_56, __v_54]; record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12286,6 +12676,7 @@ fn aiur_fn_99( let __v_50: G = __r_arr[1]; let __ret: [G; OUT_99] = [__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[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12316,6 +12707,7 @@ fn aiur_fn_100( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_100] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12356,6 +12748,7 @@ fn aiur_fn_101( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_101] = [__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[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12394,6 +12787,7 @@ fn aiur_fn_102( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -12430,6 +12824,7 @@ fn aiur_fn_102( let __v_32: G = G::from_u64(0); let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -12482,6 +12877,7 @@ fn aiur_fn_102( let __v_48: G = G::from_u64(2); let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12516,9 +12912,10 @@ fn aiur_fn_103( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_103] = [__v_12, __v_0]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12582,9 +12979,10 @@ fn aiur_fn_103( let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_103] = [__v_67, __v_65]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12626,6 +13024,7 @@ fn aiur_fn_104( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -12678,6 +13077,7 @@ fn aiur_fn_104( let __v_47: G = G::from_u64(1); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -12697,6 +13097,7 @@ fn aiur_fn_104( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -12716,6 +13117,7 @@ fn aiur_fn_104( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -12742,6 +13144,7 @@ fn aiur_fn_104( let __v_21: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -12760,6 +13163,7 @@ fn aiur_fn_104( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -12778,6 +13182,7 @@ fn aiur_fn_104( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -12796,6 +13201,7 @@ fn aiur_fn_104( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12834,6 +13240,7 @@ fn aiur_fn_105( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { @@ -12896,6 +13303,7 @@ fn aiur_fn_105( let __v_62: G = __r_arr[45]; let __ret: [G; OUT_105] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12985,6 +13393,7 @@ fn aiur_fn_106( let __v_62: G = __r_arr[1]; let __ret: [G; OUT_106] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_57, __v_59, __v_61, __v_62]; record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13010,18 +13419,20 @@ fn aiur_fn_107( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_5, __v_7]; record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_107] = [__v_0, __v_7]; record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13063,10 +13474,11 @@ fn aiur_fn_108( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_108] = [__v_23]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13091,18 +13503,20 @@ fn aiur_fn_108( match __v_27.as_canonical_u64() { 0u64 => { let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_108] = [__v_29]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_108] = [__v_30]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13144,6 +13558,7 @@ fn aiur_fn_109( 0u64 => { let __ret: [G; OUT_109] = [__v_1]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13151,6 +13566,7 @@ fn aiur_fn_109( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_13]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13173,6 +13589,7 @@ fn aiur_fn_109( 0u64 => { let __ret: [G; OUT_109] = [__v_0]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13180,6 +13597,7 @@ fn aiur_fn_109( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_23]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13216,9 +13634,10 @@ fn aiur_fn_109( let __v_49: G = G::from_u64(0); let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_109] = [__v_51]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13250,6 +13669,7 @@ fn aiur_fn_110( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_3]; record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13334,6 +13754,7 @@ fn aiur_fn_111( let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_111] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13379,9 +13800,10 @@ fn aiur_fn_112( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_112] = [__v_25, __v_2]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13391,18 +13813,20 @@ fn aiur_fn_112( 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_112] = [__v_26, __v_2]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_27: G = G::from_u64(1); let __ret: [G; OUT_112] = [__v_26, __v_27]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13431,6 +13855,7 @@ fn aiur_fn_112( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_0, __v_23]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13454,14 +13879,15 @@ fn aiur_fn_112( let __v_39: G = __r_arr[8]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_112] = [__v_46, __v_44]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13499,9 +13925,10 @@ fn aiur_fn_112( let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_112] = [__v_52, __v_50]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13518,7 +13945,7 @@ fn aiur_fn_112( const INPUT_SIZE_113: usize = 1; const IN_113: usize = 1; -const OUT_113: usize = 1; +const OUT_113: usize = 0; fn aiur_fn_113( inp: [G; IN_113], record: &mut QueryRecord, @@ -13540,11 +13967,9 @@ fn aiur_fn_113( let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { - let __v_11: G = G::from_u64(1); - let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_113] = [__v_13]; + let __ret: [G; OUT_113] = []; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13552,12 +13977,10 @@ fn aiur_fn_113( 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); }; - let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_113] = [__v_13]; + let __ret: [G; OUT_113] = []; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13593,9 +14016,10 @@ fn aiur_fn_114( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_114] = [__v_13]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13620,19 +14044,21 @@ fn aiur_fn_114( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_114] = [__v_25]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_114] = [__v_27]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13642,9 +14068,10 @@ fn aiur_fn_114( }, _ => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_114] = [__v_23]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13676,9 +14103,10 @@ fn aiur_fn_115( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_115] = [__v_7]; record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13686,6 +14114,7 @@ fn aiur_fn_115( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_5]; record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13725,12 +14154,14 @@ fn aiur_fn_116( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_116] = [__v_13]; record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_13]; record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13759,12 +14190,13 @@ fn aiur_fn_117( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_14]; record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13787,6 +14219,7 @@ fn aiur_fn_118( 1u64 => { let __ret: [G; OUT_118] = [__v_0, __v_1]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13799,6 +14232,7 @@ fn aiur_fn_118( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_118] = [__v_8, __v_9]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13829,6 +14263,7 @@ fn aiur_fn_119( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_119] = [__v_2, __v_5, __v_6]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14318,6 +14753,7 @@ fn aiur_fn_120( } let __ret: [G; OUT_120] = [__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[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14336,12 +14772,13 @@ fn aiur_fn_121( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_6]; record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14375,6 +14812,7 @@ fn aiur_fn_122( 1u64 => { let __ret: [G; OUT_122] = [__v_2]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14388,7 +14826,7 @@ fn aiur_fn_122( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; @@ -14401,6 +14839,7 @@ fn aiur_fn_122( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_122] = [__v_30]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14457,13 +14896,15 @@ fn aiur_fn_123( 1u64 => { let __ret: [G; OUT_123] = [__v_17]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_29]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14516,12 +14957,13 @@ fn aiur_fn_123( 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_732] = { let __args: [G; IN_732] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_70]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14547,6 +14989,7 @@ fn aiur_fn_124( 0u64 => { let __ret: [G; OUT_124] = [__v_0]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14559,13 +15002,14 @@ fn aiur_fn_124( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_14]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14601,12 +15045,14 @@ fn aiur_fn_125( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_125] = [__v_12]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_12]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14628,54 +15074,54 @@ fn aiur_fn_126( 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_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; - let __v_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 __v_9: G = __r_arr[0]; + if (__v_8 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - match __v_12.as_canonical_u64() { + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + if (__v_11 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); } - let __ret: [G; OUT_126] = [__v_5, __v_7]; + let __ret: [G; OUT_126] = [__v_4, __v_5]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_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 __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_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("div/mod hint: remainder is not less than the divisor".to_string()) }); } - let __ret: [G; OUT_126] = [__v_5, __v_7]; + let __ret: [G; OUT_126] = [__v_4, __v_5]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) @@ -14698,6 +15144,7 @@ fn aiur_fn_127( let __v_3: G = __r_arr[1]; let __ret: [G; OUT_127] = [__v_2]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14719,6 +15166,7 @@ fn aiur_fn_128( let __v_3: G = __r_arr[1]; let __ret: [G; OUT_128] = [__v_3]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14741,6 +15189,7 @@ fn aiur_fn_129( 1u64 => { let __ret: [G; OUT_129] = [__v_0]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14750,6 +15199,7 @@ fn aiur_fn_129( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_129] = [__v_4]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14786,10 +15236,11 @@ fn aiur_fn_130( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_130] = [__v_15]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14804,8 +15255,8 @@ fn aiur_fn_130( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; @@ -14823,6 +15274,7 @@ fn aiur_fn_130( 1u64 => { let __ret: [G; OUT_130] = [__v_21]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14830,6 +15282,7 @@ fn aiur_fn_130( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_130] = [__v_23]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14880,6 +15333,7 @@ fn aiur_fn_131( 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_131] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14920,6 +15374,7 @@ fn aiur_fn_132( 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_132] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14960,6 +15415,7 @@ fn aiur_fn_133( let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; let __ret: [G; OUT_133] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14991,9 +15447,10 @@ fn aiur_fn_134( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_134] = [__v_14]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15012,9 +15469,10 @@ fn aiur_fn_134( 1u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_134] = [__v_24]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15030,9 +15488,10 @@ fn aiur_fn_134( let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_134] = [__v_32]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15074,6 +15533,7 @@ fn aiur_fn_135( 1u64 => { let __ret: [G; OUT_135] = [__v_1]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15092,6 +15552,7 @@ fn aiur_fn_135( 1u64 => { let __ret: [G; OUT_135] = [__v_0]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15107,9 +15568,10 @@ fn aiur_fn_135( let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_135] = [__v_32]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15151,6 +15613,7 @@ fn aiur_fn_136( 1u64 => { let __ret: [G; OUT_136] = [__v_1]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15169,6 +15632,7 @@ fn aiur_fn_136( 1u64 => { let __ret: [G; OUT_136] = [__v_0]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15184,9 +15648,10 @@ fn aiur_fn_136( let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_136] = [__v_32]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15224,14 +15689,15 @@ fn aiur_fn_137( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_16]; record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15259,14 +15725,15 @@ fn aiur_fn_138( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_16]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15313,9 +15780,10 @@ fn aiur_fn_139( let __v_29: G = G::from_u64(70); let __v_30: G = G::from_u64(125); let __v_31: G = G::from_u64(182); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_139] = [__v_32]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15362,9 +15830,10 @@ fn aiur_fn_140( let __v_29: G = G::from_u64(186); let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(110); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_140] = [__v_32]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15411,9 +15880,10 @@ fn aiur_fn_141( let __v_29: G = G::from_u64(89); let __v_30: G = G::from_u64(76); let __v_31: G = G::from_u64(136); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_141] = [__v_32]; record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15428,41 +15898,42 @@ fn aiur_fn_142( unconstrained: bool, ) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(94); - let __v_1: G = G::from_u64(215); - let __v_2: G = G::from_u64(142); - let __v_3: G = G::from_u64(224); - let __v_4: G = G::from_u64(129); - let __v_5: G = G::from_u64(225); - let __v_6: G = G::from_u64(11); - let __v_7: G = G::from_u64(192); - let __v_8: G = G::from_u64(153); - let __v_9: G = G::from_u64(154); - let __v_10: G = G::from_u64(55); - let __v_11: G = G::from_u64(42); - let __v_12: G = G::from_u64(94); - let __v_13: G = G::from_u64(84); - let __v_14: G = G::from_u64(172); - let __v_15: G = G::from_u64(211); - let __v_16: G = G::from_u64(55); - let __v_17: G = G::from_u64(61); - let __v_18: G = G::from_u64(133); - let __v_19: G = G::from_u64(212); - let __v_20: G = G::from_u64(30); - let __v_21: G = G::from_u64(155); - let __v_22: G = G::from_u64(227); - let __v_23: G = G::from_u64(250); - let __v_24: G = G::from_u64(117); - let __v_25: G = G::from_u64(253); - let __v_26: G = G::from_u64(222); - let __v_27: G = G::from_u64(50); - let __v_28: G = G::from_u64(219); - let __v_29: G = G::from_u64(45); - let __v_30: G = G::from_u64(101); - let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(214); + let __v_1: G = G::from_u64(246); + let __v_2: G = G::from_u64(42); + let __v_3: G = G::from_u64(151); + let __v_4: G = G::from_u64(121); + let __v_5: G = G::from_u64(16); + let __v_6: G = G::from_u64(143); + let __v_7: G = G::from_u64(159); + let __v_8: G = G::from_u64(182); + let __v_9: G = G::from_u64(182); + let __v_10: G = G::from_u64(107); + let __v_11: G = G::from_u64(49); + let __v_12: G = G::from_u64(204); + let __v_13: G = G::from_u64(148); + let __v_14: G = G::from_u64(195); + let __v_15: G = G::from_u64(216); + let __v_16: G = G::from_u64(76); + let __v_17: G = G::from_u64(167); + let __v_18: G = G::from_u64(45); + let __v_19: G = G::from_u64(139); + let __v_20: G = G::from_u64(234); + let __v_21: G = G::from_u64(24); + let __v_22: G = G::from_u64(94); + let __v_23: G = G::from_u64(19); + let __v_24: G = G::from_u64(19); + let __v_25: G = G::from_u64(124); + let __v_26: G = G::from_u64(80); + let __v_27: G = G::from_u64(199); + let __v_28: G = G::from_u64(239); + let __v_29: G = G::from_u64(132); + let __v_30: G = G::from_u64(201); + let __v_31: G = G::from_u64(105); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_142] = [__v_32]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15477,41 +15948,42 @@ fn aiur_fn_143( unconstrained: bool, ) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(97); - let __v_1: G = G::from_u64(15); - let __v_2: G = G::from_u64(229); - let __v_3: G = G::from_u64(164); - let __v_4: G = G::from_u64(245); - let __v_5: G = G::from_u64(160); - let __v_6: G = G::from_u64(63); - let __v_7: G = G::from_u64(100); - let __v_8: G = G::from_u64(246); - let __v_9: G = G::from_u64(14); - let __v_10: G = G::from_u64(245); - let __v_11: G = G::from_u64(160); - let __v_12: G = G::from_u64(105); - let __v_13: G = G::from_u64(241); - let __v_14: G = G::from_u64(100); - let __v_15: G = G::from_u64(7); - let __v_16: G = G::from_u64(88); - let __v_17: G = G::from_u64(224); - let __v_18: G = G::from_u64(0); - let __v_19: G = G::from_u64(161); - let __v_20: G = G::from_u64(180); - let __v_21: G = G::from_u64(213); - let __v_22: G = G::from_u64(127); - let __v_23: G = G::from_u64(213); - let __v_24: G = G::from_u64(148); - let __v_25: G = G::from_u64(134); - let __v_26: G = G::from_u64(110); - let __v_27: G = G::from_u64(159); - let __v_28: G = G::from_u64(107); - let __v_29: G = G::from_u64(51); - let __v_30: G = G::from_u64(129); - let __v_31: G = G::from_u64(237); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(253); + let __v_1: G = G::from_u64(189); + let __v_2: G = G::from_u64(95); + let __v_3: G = G::from_u64(239); + let __v_4: G = G::from_u64(64); + let __v_5: G = G::from_u64(20); + let __v_6: G = G::from_u64(156); + let __v_7: G = G::from_u64(133); + let __v_8: G = G::from_u64(51); + let __v_9: G = G::from_u64(60); + let __v_10: G = G::from_u64(111); + let __v_11: G = G::from_u64(60); + let __v_12: G = G::from_u64(206); + let __v_13: G = G::from_u64(187); + let __v_14: G = G::from_u64(75); + let __v_15: G = G::from_u64(231); + let __v_16: G = G::from_u64(65); + let __v_17: G = G::from_u64(39); + let __v_18: G = G::from_u64(13); + let __v_19: G = G::from_u64(32); + let __v_20: G = G::from_u64(102); + let __v_21: G = G::from_u64(51); + let __v_22: G = G::from_u64(108); + let __v_23: G = G::from_u64(178); + let __v_24: G = G::from_u64(238); + let __v_25: G = G::from_u64(248); + let __v_26: G = G::from_u64(118); + let __v_27: G = G::from_u64(35); + let __v_28: G = G::from_u64(116); + let __v_29: G = G::from_u64(75); + let __v_30: G = G::from_u64(114); + let __v_31: G = G::from_u64(176); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_143] = [__v_32]; record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15526,41 +15998,42 @@ fn aiur_fn_144( unconstrained: bool, ) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(218); - let __v_1: G = G::from_u64(111); - let __v_2: G = G::from_u64(183); - let __v_3: G = G::from_u64(37); - let __v_4: G = G::from_u64(128); - let __v_5: G = G::from_u64(61); - let __v_6: G = G::from_u64(183); - let __v_7: G = G::from_u64(159); - let __v_8: G = G::from_u64(49); - let __v_9: G = G::from_u64(142); - let __v_10: G = G::from_u64(138); - let __v_11: G = G::from_u64(239); - let __v_12: G = G::from_u64(91); - let __v_13: G = G::from_u64(25); - let __v_14: G = G::from_u64(225); - let __v_15: G = G::from_u64(212); - let __v_16: G = G::from_u64(194); - let __v_17: G = G::from_u64(209); - let __v_18: G = G::from_u64(167); - let __v_19: G = G::from_u64(196); - let __v_20: G = G::from_u64(24); - let __v_21: G = G::from_u64(49); - let __v_22: G = G::from_u64(223); - let __v_23: G = G::from_u64(72); - let __v_24: G = G::from_u64(120); - let __v_25: G = G::from_u64(126); - let __v_26: G = G::from_u64(138); - let __v_27: G = G::from_u64(49); - let __v_28: G = G::from_u64(155); - let __v_29: G = G::from_u64(140); - let __v_30: G = G::from_u64(72); - let __v_31: G = G::from_u64(211); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(102); + let __v_1: G = G::from_u64(73); + let __v_2: G = G::from_u64(102); + let __v_3: G = G::from_u64(86); + let __v_4: G = G::from_u64(7); + let __v_5: G = G::from_u64(176); + let __v_6: G = G::from_u64(117); + let __v_7: G = G::from_u64(12); + let __v_8: G = G::from_u64(44); + let __v_9: G = G::from_u64(167); + let __v_10: G = G::from_u64(63); + let __v_11: G = G::from_u64(69); + let __v_12: G = G::from_u64(222); + let __v_13: G = G::from_u64(96); + let __v_14: G = G::from_u64(15); + let __v_15: G = G::from_u64(33); + let __v_16: G = G::from_u64(203); + let __v_17: G = G::from_u64(103); + let __v_18: G = G::from_u64(3); + let __v_19: G = G::from_u64(152); + let __v_20: G = G::from_u64(80); + let __v_21: G = G::from_u64(72); + let __v_22: G = G::from_u64(101); + let __v_23: G = G::from_u64(187); + let __v_24: G = G::from_u64(151); + let __v_25: G = G::from_u64(151); + let __v_26: G = G::from_u64(36); + let __v_27: G = G::from_u64(56); + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(79); + let __v_30: G = G::from_u64(150); + let __v_31: G = G::from_u64(217); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_144] = [__v_32]; record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15575,41 +16048,42 @@ fn aiur_fn_145( unconstrained: bool, ) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(171); - let __v_1: G = G::from_u64(111); - let __v_2: G = G::from_u64(63); - let __v_3: G = G::from_u64(28); - let __v_4: G = G::from_u64(173); - let __v_5: G = G::from_u64(99); - let __v_6: G = G::from_u64(108); - let __v_7: G = G::from_u64(238); - let __v_8: G = G::from_u64(182); - let __v_9: G = G::from_u64(125); - let __v_10: G = G::from_u64(247); - let __v_11: G = G::from_u64(73); - let __v_12: G = G::from_u64(205); - let __v_13: G = G::from_u64(124); - let __v_14: G = G::from_u64(198); - let __v_15: G = G::from_u64(52); - let __v_16: G = G::from_u64(162); - let __v_17: G = G::from_u64(214); - let __v_18: G = G::from_u64(138); - let __v_19: G = G::from_u64(235); - let __v_20: G = G::from_u64(84); - let __v_21: G = G::from_u64(37); - let __v_22: G = G::from_u64(94); - let __v_23: G = G::from_u64(8); - let __v_24: G = G::from_u64(92); - let __v_25: G = G::from_u64(167); - let __v_26: G = G::from_u64(239); - let __v_27: G = G::from_u64(105); - let __v_28: G = G::from_u64(43); - let __v_29: G = G::from_u64(57); - let __v_30: G = G::from_u64(94); - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(51); + let __v_1: G = G::from_u64(198); + let __v_2: G = G::from_u64(4); + let __v_3: G = G::from_u64(69); + let __v_4: G = G::from_u64(29); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(203); + let __v_7: G = G::from_u64(25); + let __v_8: G = G::from_u64(164); + let __v_9: G = G::from_u64(51); + let __v_10: G = G::from_u64(102); + let __v_11: G = G::from_u64(130); + let __v_12: G = G::from_u64(70); + let __v_13: G = G::from_u64(185); + let __v_14: G = G::from_u64(143); + let __v_15: G = G::from_u64(110); + let __v_16: G = G::from_u64(135); + let __v_17: G = G::from_u64(75); + let __v_18: G = G::from_u64(214); + let __v_19: G = G::from_u64(48); + let __v_20: G = G::from_u64(183); + let __v_21: G = G::from_u64(138); + let __v_22: G = G::from_u64(121); + let __v_23: G = G::from_u64(29); + let __v_24: G = G::from_u64(122); + let __v_25: G = G::from_u64(55); + let __v_26: G = G::from_u64(58); + let __v_27: G = G::from_u64(151); + let __v_28: G = G::from_u64(152); + let __v_29: G = G::from_u64(73); + let __v_30: G = G::from_u64(161); + let __v_31: G = G::from_u64(207); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_145] = [__v_32]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15624,41 +16098,42 @@ fn aiur_fn_146( unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(140); - let __v_1: G = G::from_u64(212); - let __v_2: G = G::from_u64(25); - let __v_3: G = G::from_u64(144); - let __v_4: G = G::from_u64(68); - let __v_5: G = G::from_u64(73); - let __v_6: G = G::from_u64(164); - let __v_7: G = G::from_u64(217); - let __v_8: G = G::from_u64(27); - let __v_9: G = G::from_u64(234); - let __v_10: G = G::from_u64(184); - let __v_11: G = G::from_u64(77); - let __v_12: G = G::from_u64(194); - let __v_13: G = G::from_u64(107); - let __v_14: G = G::from_u64(72); - let __v_15: G = G::from_u64(178); - let __v_16: G = G::from_u64(22); - let __v_17: G = G::from_u64(218); - let __v_18: G = G::from_u64(254); - let __v_19: G = G::from_u64(22); - let __v_20: G = G::from_u64(54); - let __v_21: G = G::from_u64(215); - let __v_22: G = G::from_u64(31); - let __v_23: G = G::from_u64(72); - let __v_24: G = G::from_u64(220); - let __v_25: G = G::from_u64(192); - let __v_26: G = G::from_u64(210); - let __v_27: G = G::from_u64(12); - let __v_28: G = G::from_u64(159); - let __v_29: G = G::from_u64(237); - let __v_30: G = G::from_u64(16); - let __v_31: G = G::from_u64(235); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(59); + let __v_1: G = G::from_u64(228); + let __v_2: G = G::from_u64(131); + let __v_3: G = G::from_u64(87); + let __v_4: G = G::from_u64(174); + let __v_5: G = G::from_u64(23); + let __v_6: G = G::from_u64(247); + let __v_7: G = G::from_u64(77); + let __v_8: G = G::from_u64(77); + let __v_9: G = G::from_u64(242); + let __v_10: G = G::from_u64(125); + let __v_11: G = G::from_u64(105); + let __v_12: G = G::from_u64(122); + let __v_13: G = G::from_u64(237); + let __v_14: G = G::from_u64(63); + let __v_15: G = G::from_u64(71); + let __v_16: G = G::from_u64(193); + let __v_17: G = G::from_u64(48); + let __v_18: G = G::from_u64(121); + let __v_19: G = G::from_u64(65); + let __v_20: G = G::from_u64(244); + let __v_21: G = G::from_u64(26); + let __v_22: G = G::from_u64(255); + let __v_23: G = G::from_u64(207); + let __v_24: G = G::from_u64(116); + let __v_25: G = G::from_u64(218); + let __v_26: G = G::from_u64(95); + let __v_27: G = G::from_u64(102); + let __v_28: G = G::from_u64(213); + let __v_29: G = G::from_u64(17); + let __v_30: G = G::from_u64(167); + let __v_31: G = G::from_u64(151); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_146] = [__v_32]; record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15673,41 +16148,42 @@ fn aiur_fn_147( unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(79); - let __v_1: G = G::from_u64(201); - let __v_2: G = G::from_u64(21); - let __v_3: G = G::from_u64(136); - let __v_4: G = G::from_u64(208); - let __v_5: G = G::from_u64(176); - let __v_6: G = G::from_u64(78); - let __v_7: G = G::from_u64(233); - let __v_8: G = G::from_u64(235); - let __v_9: G = G::from_u64(34); - let __v_10: G = G::from_u64(1); - let __v_11: G = G::from_u64(200); - let __v_12: G = G::from_u64(11); - let __v_13: G = G::from_u64(114); - let __v_14: G = G::from_u64(179); - let __v_15: G = G::from_u64(157); - let __v_16: G = G::from_u64(239); - let __v_17: G = G::from_u64(161); - let __v_18: G = G::from_u64(237); - let __v_19: G = G::from_u64(244); - let __v_20: G = G::from_u64(92); - let __v_21: G = G::from_u64(130); - let __v_22: G = G::from_u64(229); - let __v_23: G = G::from_u64(234); - let __v_24: G = G::from_u64(227); - let __v_25: G = G::from_u64(78); - let __v_26: G = G::from_u64(31); - let __v_27: G = G::from_u64(113); - let __v_28: G = G::from_u64(133); - let __v_29: G = G::from_u64(141); - let __v_30: G = G::from_u64(118); - let __v_31: G = G::from_u64(182); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(81); + let __v_1: G = G::from_u64(121); + let __v_2: G = G::from_u64(99); + let __v_3: G = G::from_u64(139); + let __v_4: G = G::from_u64(130); + let __v_5: G = G::from_u64(204); + let __v_6: G = G::from_u64(131); + let __v_7: G = G::from_u64(55); + let __v_8: G = G::from_u64(145); + let __v_9: G = G::from_u64(74); + let __v_10: G = G::from_u64(123); + let __v_11: G = G::from_u64(202); + let __v_12: G = G::from_u64(173); + let __v_13: G = G::from_u64(133); + let __v_14: G = G::from_u64(140); + let __v_15: G = G::from_u64(133); + let __v_16: G = G::from_u64(136); + let __v_17: G = G::from_u64(136); + let __v_18: G = G::from_u64(68); + let __v_19: G = G::from_u64(233); + let __v_20: G = G::from_u64(162); + let __v_21: G = G::from_u64(146); + let __v_22: G = G::from_u64(67); + let __v_23: G = G::from_u64(12); + let __v_24: G = G::from_u64(172); + let __v_25: G = G::from_u64(81); + let __v_26: G = G::from_u64(229); + let __v_27: G = G::from_u64(234); + let __v_28: G = G::from_u64(220); + let __v_29: G = G::from_u64(65); + let __v_30: G = G::from_u64(161); + let __v_31: G = G::from_u64(175); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_147] = [__v_32]; record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15722,41 +16198,42 @@ fn aiur_fn_148( unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(131); - let __v_1: G = G::from_u64(194); - let __v_2: G = G::from_u64(112); - let __v_3: G = G::from_u64(56); - let __v_4: G = G::from_u64(142); - let __v_5: G = G::from_u64(64); - let __v_6: G = G::from_u64(74); - let __v_7: G = G::from_u64(45); - let __v_8: G = G::from_u64(204); - let __v_9: G = G::from_u64(153); - let __v_10: G = G::from_u64(36); - let __v_11: G = G::from_u64(242); - let __v_12: G = G::from_u64(72); - let __v_13: G = G::from_u64(39); - let __v_14: G = G::from_u64(130); - let __v_15: G = G::from_u64(217); - let __v_16: G = G::from_u64(222); - let __v_17: G = G::from_u64(191); - let __v_18: G = G::from_u64(113); - let __v_19: G = G::from_u64(102); - let __v_20: G = G::from_u64(243); - let __v_21: G = G::from_u64(210); - let __v_22: G = G::from_u64(224); - let __v_23: G = G::from_u64(118); - let __v_24: G = G::from_u64(58); - let __v_25: G = G::from_u64(120); - let __v_26: G = G::from_u64(40); - let __v_27: G = G::from_u64(23); - let __v_28: G = G::from_u64(43); - let __v_29: G = G::from_u64(140); - let __v_30: G = G::from_u64(19); - let __v_31: G = G::from_u64(30); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(137); + let __v_1: G = G::from_u64(222); + let __v_2: G = G::from_u64(202); + let __v_3: G = G::from_u64(134); + let __v_4: G = G::from_u64(221); + let __v_5: G = G::from_u64(143); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(102); + let __v_8: G = G::from_u64(165); + let __v_9: G = G::from_u64(6); + let __v_10: G = G::from_u64(79); + let __v_11: G = G::from_u64(219); + let __v_12: G = G::from_u64(25); + let __v_13: G = G::from_u64(162); + let __v_14: G = G::from_u64(198); + let __v_15: G = G::from_u64(137); + let __v_16: G = G::from_u64(122); + let __v_17: G = G::from_u64(58); + let __v_18: G = G::from_u64(152); + let __v_19: G = G::from_u64(103); + let __v_20: G = G::from_u64(202); + let __v_21: G = G::from_u64(173); + let __v_22: G = G::from_u64(192); + let __v_23: G = G::from_u64(79); + let __v_24: G = G::from_u64(119); + let __v_25: G = G::from_u64(141); + let __v_26: G = G::from_u64(92); + let __v_27: G = G::from_u64(92); + let __v_28: G = G::from_u64(208); + let __v_29: G = G::from_u64(34); + let __v_30: G = G::from_u64(83); + let __v_31: G = G::from_u64(98); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_148] = [__v_32]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15771,41 +16248,42 @@ fn aiur_fn_149( unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(100); - let __v_1: G = G::from_u64(225); - let __v_2: G = G::from_u64(130); - let __v_3: G = G::from_u64(206); - let __v_4: G = G::from_u64(243); - let __v_5: G = G::from_u64(60); - let __v_6: G = G::from_u64(183); - let __v_7: G = G::from_u64(23); - let __v_8: G = G::from_u64(183); - let __v_9: G = G::from_u64(136); - let __v_10: G = G::from_u64(64); - let __v_11: G = G::from_u64(77); - let __v_12: G = G::from_u64(49); - let __v_13: G = G::from_u64(186); - let __v_14: G = G::from_u64(210); - let __v_15: G = G::from_u64(16); - let __v_16: G = G::from_u64(61); - let __v_17: G = G::from_u64(26); - let __v_18: G = G::from_u64(251); - let __v_19: G = G::from_u64(118); - let __v_20: G = G::from_u64(219); - let __v_21: G = G::from_u64(84); - let __v_22: G = G::from_u64(71); - let __v_23: G = G::from_u64(186); - let __v_24: G = G::from_u64(52); - let __v_25: G = G::from_u64(50); - let __v_26: G = G::from_u64(216); - let __v_27: G = G::from_u64(63); - let __v_28: G = G::from_u64(114); - let __v_29: G = G::from_u64(203); - let __v_30: G = G::from_u64(155); - let __v_31: G = G::from_u64(244); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(129); + let __v_1: G = G::from_u64(138); + let __v_2: G = G::from_u64(187); + let __v_3: G = G::from_u64(51); + let __v_4: G = G::from_u64(17); + let __v_5: G = G::from_u64(80); + let __v_6: G = G::from_u64(64); + let __v_7: G = G::from_u64(13); + let __v_8: G = G::from_u64(16); + let __v_9: G = G::from_u64(179); + let __v_10: G = G::from_u64(79); + let __v_11: G = G::from_u64(174); + let __v_12: G = G::from_u64(77); + let __v_13: G = G::from_u64(251); + let __v_14: G = G::from_u64(148); + let __v_15: G = G::from_u64(38); + let __v_16: G = G::from_u64(116); + let __v_17: G = G::from_u64(28); + let __v_18: G = G::from_u64(70); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(186); + let __v_21: G = G::from_u64(238); + let __v_22: G = G::from_u64(216); + let __v_23: G = G::from_u64(217); + let __v_24: G = G::from_u64(98); + let __v_25: G = G::from_u64(113); + let __v_26: G = G::from_u64(186); + let __v_27: G = G::from_u64(22); + let __v_28: G = G::from_u64(89); + let __v_29: G = G::from_u64(5); + let __v_30: G = G::from_u64(142); + let __v_31: G = G::from_u64(248); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_149] = [__v_32]; record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15820,41 +16298,42 @@ fn aiur_fn_150( unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(215); - let __v_1: G = G::from_u64(93); - let __v_2: G = G::from_u64(225); - let __v_3: G = G::from_u64(42); - let __v_4: G = G::from_u64(88); - let __v_5: G = G::from_u64(75); - let __v_6: G = G::from_u64(213); - let __v_7: G = G::from_u64(254); - let __v_8: G = G::from_u64(186); - let __v_9: G = G::from_u64(248); - let __v_10: G = G::from_u64(154); - let __v_11: G = G::from_u64(119); - let __v_12: G = G::from_u64(40); - let __v_13: G = G::from_u64(220); - let __v_14: G = G::from_u64(98); - let __v_15: G = G::from_u64(112); - let __v_16: G = G::from_u64(237); - let __v_17: G = G::from_u64(56); - let __v_18: G = G::from_u64(174); - let __v_19: G = G::from_u64(23); - let __v_20: G = G::from_u64(151); - let __v_21: G = G::from_u64(255); - let __v_22: G = G::from_u64(90); - let __v_23: G = G::from_u64(68); - let __v_24: G = G::from_u64(104); - let __v_25: G = G::from_u64(59); - let __v_26: G = G::from_u64(141); - let __v_27: G = G::from_u64(241); - let __v_28: G = G::from_u64(89); - let __v_29: G = G::from_u64(80); - let __v_30: G = G::from_u64(153); - let __v_31: G = G::from_u64(148); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(155); + let __v_1: G = G::from_u64(118); + let __v_2: G = G::from_u64(243); + let __v_3: G = G::from_u64(43); + let __v_4: G = G::from_u64(187); + let __v_5: G = G::from_u64(29); + let __v_6: G = G::from_u64(189); + let __v_7: G = G::from_u64(244); + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(104); + let __v_10: G = G::from_u64(224); + let __v_11: G = G::from_u64(34); + let __v_12: G = G::from_u64(18); + let __v_13: G = G::from_u64(37); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(93); + let __v_16: G = G::from_u64(240); + let __v_17: G = G::from_u64(202); + let __v_18: G = G::from_u64(45); + let __v_19: G = G::from_u64(42); + let __v_20: G = G::from_u64(96); + let __v_21: G = G::from_u64(35); + let __v_22: G = G::from_u64(193); + let __v_23: G = G::from_u64(168); + let __v_24: G = G::from_u64(19); + let __v_25: G = G::from_u64(6); + let __v_26: G = G::from_u64(212); + let __v_27: G = G::from_u64(2); + let __v_28: G = G::from_u64(13); + let __v_29: G = G::from_u64(78); + let __v_30: G = G::from_u64(243); + let __v_31: G = G::from_u64(151); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_150] = [__v_32]; record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15869,41 +16348,42 @@ fn aiur_fn_151( unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(12); - let __v_1: G = G::from_u64(103); - let __v_2: G = G::from_u64(136); - let __v_3: G = G::from_u64(181); - let __v_4: G = G::from_u64(141); - let __v_5: G = G::from_u64(149); - let __v_6: G = G::from_u64(104); - let __v_7: G = G::from_u64(204); - let __v_8: G = G::from_u64(17); - let __v_9: G = G::from_u64(138); - let __v_10: G = G::from_u64(155); - let __v_11: G = G::from_u64(10); - let __v_12: G = G::from_u64(134); - let __v_13: G = G::from_u64(30); - let __v_14: G = G::from_u64(135); - let __v_15: G = G::from_u64(39); - let __v_16: G = G::from_u64(50); - let __v_17: G = G::from_u64(219); - let __v_18: G = G::from_u64(184); - let __v_19: G = G::from_u64(69); - let __v_20: G = G::from_u64(54); - let __v_21: G = G::from_u64(71); - let __v_22: G = G::from_u64(234); - let __v_23: G = G::from_u64(157); - let __v_24: G = G::from_u64(96); - let __v_25: G = G::from_u64(19); - let __v_26: G = G::from_u64(81); - let __v_27: G = G::from_u64(82); - let __v_28: G = G::from_u64(68); - let __v_29: G = G::from_u64(230); - let __v_30: G = G::from_u64(14); - let __v_31: G = G::from_u64(56); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(151); + let __v_1: G = G::from_u64(227); + let __v_2: G = G::from_u64(37); + let __v_3: G = G::from_u64(169); + let __v_4: G = G::from_u64(106); + let __v_5: G = G::from_u64(106); + let __v_6: G = G::from_u64(24); + let __v_7: G = G::from_u64(39); + let __v_8: G = G::from_u64(25); + let __v_9: G = G::from_u64(78); + let __v_10: G = G::from_u64(235); + let __v_11: G = G::from_u64(125); + let __v_12: G = G::from_u64(42); + let __v_13: G = G::from_u64(160); + let __v_14: G = G::from_u64(217); + let __v_15: G = G::from_u64(25); + let __v_16: G = G::from_u64(33); + let __v_17: G = G::from_u64(7); + let __v_18: G = G::from_u64(58); + let __v_19: G = G::from_u64(239); + let __v_20: G = G::from_u64(156); + let __v_21: G = G::from_u64(45); + let __v_22: G = G::from_u64(51); + let __v_23: G = G::from_u64(60); + let __v_24: G = G::from_u64(36); + let __v_25: G = G::from_u64(97); + let __v_26: G = G::from_u64(62); + let __v_27: G = G::from_u64(154); + let __v_28: G = G::from_u64(201); + let __v_29: G = G::from_u64(86); + let __v_30: G = G::from_u64(237); + let __v_31: G = G::from_u64(41); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_151] = [__v_32]; record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15918,41 +16398,42 @@ fn aiur_fn_152( unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(66); - let __v_1: G = G::from_u64(76); - let __v_2: G = G::from_u64(54); - let __v_3: G = G::from_u64(238); - let __v_4: G = G::from_u64(20); - let __v_5: G = G::from_u64(54); - let __v_6: G = G::from_u64(42); - let __v_7: G = G::from_u64(231); - let __v_8: G = G::from_u64(52); - let __v_9: G = G::from_u64(45); - let __v_10: G = G::from_u64(21); - let __v_11: G = G::from_u64(39); - let __v_12: G = G::from_u64(210); - let __v_13: G = G::from_u64(81); - let __v_14: G = G::from_u64(212); - let __v_15: G = G::from_u64(55); + let __v_0: G = G::from_u64(220); + let __v_1: G = G::from_u64(129); + let __v_2: G = G::from_u64(228); + let __v_3: G = G::from_u64(28); + let __v_4: G = G::from_u64(173); + let __v_5: G = G::from_u64(17); + let __v_6: G = G::from_u64(144); + let __v_7: G = G::from_u64(55); + let __v_8: G = G::from_u64(125); + let __v_9: G = G::from_u64(190); + let __v_10: G = G::from_u64(96); + let __v_11: G = G::from_u64(75); + let __v_12: G = G::from_u64(252); + let __v_13: G = G::from_u64(58); + let __v_14: G = G::from_u64(254); + let __v_15: G = G::from_u64(101); let __v_16: G = G::from_u64(138); - let __v_17: G = G::from_u64(253); - let __v_18: G = G::from_u64(42); - let __v_19: G = G::from_u64(69); - let __v_20: G = G::from_u64(163); - let __v_21: G = G::from_u64(181); - let __v_22: G = G::from_u64(9); - let __v_23: G = G::from_u64(125); - let __v_24: G = G::from_u64(45); - let __v_25: G = G::from_u64(42); - let __v_26: G = G::from_u64(224); - let __v_27: G = G::from_u64(50); - let __v_28: G = G::from_u64(29); - let __v_29: G = G::from_u64(95); - let __v_30: G = G::from_u64(159); - let __v_31: G = G::from_u64(255); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(65); + let __v_18: G = G::from_u64(59); + let __v_19: G = G::from_u64(154); + let __v_20: G = G::from_u64(45); + let __v_21: G = G::from_u64(207); + let __v_22: G = G::from_u64(188); + let __v_23: G = G::from_u64(171); + let __v_24: G = G::from_u64(121); + let __v_25: G = G::from_u64(250); + let __v_26: G = G::from_u64(215); + let __v_27: G = G::from_u64(183); + let __v_28: G = G::from_u64(165); + let __v_29: G = G::from_u64(205); + let __v_30: G = G::from_u64(217); + let __v_31: G = G::from_u64(84); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_152] = [__v_32]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15967,41 +16448,42 @@ fn aiur_fn_153( unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(170); - let __v_1: G = G::from_u64(155); - let __v_2: G = G::from_u64(97); - let __v_3: G = G::from_u64(190); - let __v_4: G = G::from_u64(220); - let __v_5: G = G::from_u64(158); - let __v_6: G = G::from_u64(230); - let __v_7: G = G::from_u64(169); - let __v_8: G = G::from_u64(144); - let __v_9: G = G::from_u64(141); - let __v_10: G = G::from_u64(95); - let __v_11: G = G::from_u64(14); - let __v_12: G = G::from_u64(152); - let __v_13: G = G::from_u64(149); - let __v_14: G = G::from_u64(95); - let __v_15: G = G::from_u64(24); - let __v_16: G = G::from_u64(51); - let __v_17: G = G::from_u64(15); - let __v_18: G = G::from_u64(56); - let __v_19: G = G::from_u64(88); - let __v_20: G = G::from_u64(125); - let __v_21: G = G::from_u64(247); - let __v_22: G = G::from_u64(16); - let __v_23: G = G::from_u64(253); - let __v_24: G = G::from_u64(235); - let __v_25: G = G::from_u64(228); - let __v_26: G = G::from_u64(21); - let __v_27: G = G::from_u64(206); - let __v_28: G = G::from_u64(199); - let __v_29: G = G::from_u64(218); - let __v_30: G = G::from_u64(41); - let __v_31: G = G::from_u64(237); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(109); + let __v_1: G = G::from_u64(180); + let __v_2: G = G::from_u64(147); + let __v_3: G = G::from_u64(4); + let __v_4: G = G::from_u64(191); + let __v_5: G = G::from_u64(15); + let __v_6: G = G::from_u64(90); + let __v_7: G = G::from_u64(203); + let __v_8: G = G::from_u64(253); + let __v_9: G = G::from_u64(29); + let __v_10: G = G::from_u64(157); + let __v_11: G = G::from_u64(154); + let __v_12: G = G::from_u64(12); + let __v_13: G = G::from_u64(27); + let __v_14: G = G::from_u64(122); + let __v_15: G = G::from_u64(226); + let __v_16: G = G::from_u64(14); + let __v_17: G = G::from_u64(249); + let __v_18: G = G::from_u64(157); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(55); + let __v_21: G = G::from_u64(136); + let __v_22: G = G::from_u64(112); + let __v_23: G = G::from_u64(86); + let __v_24: G = G::from_u64(18); + let __v_25: G = G::from_u64(159); + let __v_26: G = G::from_u64(91); + let __v_27: G = G::from_u64(92); + let __v_28: G = G::from_u64(181); + let __v_29: G = G::from_u64(169); + let __v_30: G = G::from_u64(186); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_153] = [__v_32]; record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16016,41 +16498,42 @@ fn aiur_fn_154( unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(253); - let __v_1: G = G::from_u64(134); - let __v_2: G = G::from_u64(37); - let __v_3: G = G::from_u64(213); - let __v_4: G = G::from_u64(22); - let __v_5: G = G::from_u64(96); - let __v_6: G = G::from_u64(81); - let __v_7: G = G::from_u64(3); - let __v_8: G = G::from_u64(191); - let __v_9: G = G::from_u64(142); - let __v_10: G = G::from_u64(1); - let __v_11: G = G::from_u64(154); - let __v_12: G = G::from_u64(93); - let __v_13: G = G::from_u64(134); - let __v_14: G = G::from_u64(212); - let __v_15: G = G::from_u64(125); - let __v_16: G = G::from_u64(52); - let __v_17: G = G::from_u64(221); - let __v_18: G = G::from_u64(71); - let __v_19: G = G::from_u64(193); - let __v_20: G = G::from_u64(239); - let __v_21: G = G::from_u64(100); + let __v_0: G = G::from_u64(163); + let __v_1: G = G::from_u64(74); + let __v_2: G = G::from_u64(178); + let __v_3: G = G::from_u64(218); + let __v_4: G = G::from_u64(186); + let __v_5: G = G::from_u64(52); + let __v_6: G = G::from_u64(131); + let __v_7: G = G::from_u64(158); + let __v_8: G = G::from_u64(133); + let __v_9: G = G::from_u64(31); + let __v_10: G = G::from_u64(163); + let __v_11: G = G::from_u64(103); + let __v_12: G = G::from_u64(81); + let __v_13: G = G::from_u64(36); + let __v_14: G = G::from_u64(86); + let __v_15: G = G::from_u64(111); + let __v_16: G = G::from_u64(159); + let __v_17: G = G::from_u64(77); + let __v_18: G = G::from_u64(205); + let __v_19: G = G::from_u64(229); + let __v_20: G = G::from_u64(151); + let __v_21: G = G::from_u64(52); let __v_22: G = G::from_u64(158); - let __v_23: G = G::from_u64(61); - let __v_24: G = G::from_u64(236); - let __v_25: G = G::from_u64(15); - let __v_26: G = G::from_u64(166); - let __v_27: G = G::from_u64(151); - let __v_28: G = G::from_u64(187); - let __v_29: G = G::from_u64(253); - let __v_30: G = G::from_u64(158); - let __v_31: G = G::from_u64(65); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(205); + let __v_24: G = G::from_u64(84); + let __v_25: G = G::from_u64(174); + let __v_26: G = G::from_u64(50); + let __v_27: G = G::from_u64(248); + let __v_28: G = G::from_u64(66); + let __v_29: G = G::from_u64(78); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_154] = [__v_32]; record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16065,41 +16548,42 @@ fn aiur_fn_155( unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(218); - let __v_1: G = G::from_u64(63); - let __v_2: G = G::from_u64(149); - let __v_3: G = G::from_u64(8); - let __v_4: G = G::from_u64(119); - let __v_5: G = G::from_u64(130); - let __v_6: G = G::from_u64(244); - let __v_7: G = G::from_u64(7); - let __v_8: G = G::from_u64(67); - let __v_9: G = G::from_u64(22); - let __v_10: G = G::from_u64(139); - let __v_11: G = G::from_u64(217); - let __v_12: G = G::from_u64(23); - let __v_13: G = G::from_u64(109); - let __v_14: G = G::from_u64(220); - let __v_15: G = G::from_u64(222); - let __v_16: G = G::from_u64(100); - let __v_17: G = G::from_u64(191); - let __v_18: G = G::from_u64(90); - let __v_19: G = G::from_u64(77); - let __v_20: G = G::from_u64(80); - let __v_21: G = G::from_u64(52); - let __v_22: G = G::from_u64(99); - let __v_23: G = G::from_u64(195); - let __v_24: G = G::from_u64(213); - let __v_25: G = G::from_u64(238); - let __v_26: G = G::from_u64(244); - let __v_27: G = G::from_u64(202); - let __v_28: G = G::from_u64(46); - let __v_29: G = G::from_u64(250); - let __v_30: G = G::from_u64(237); - let __v_31: G = G::from_u64(35); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(222); + let __v_1: G = G::from_u64(11); + let __v_2: G = G::from_u64(239); + let __v_3: G = G::from_u64(168); + let __v_4: G = G::from_u64(79); + let __v_5: G = G::from_u64(170); + let __v_6: G = G::from_u64(34); + let __v_7: G = G::from_u64(209); + let __v_8: G = G::from_u64(57); + let __v_9: G = G::from_u64(67); + let __v_10: G = G::from_u64(121); + let __v_11: G = G::from_u64(160); + let __v_12: G = G::from_u64(186); + let __v_13: G = G::from_u64(103); + let __v_14: G = G::from_u64(41); + let __v_15: G = G::from_u64(110); + let __v_16: G = G::from_u64(17); + let __v_17: G = G::from_u64(102); + let __v_18: G = G::from_u64(96); + let __v_19: G = G::from_u64(247); + let __v_20: G = G::from_u64(129); + let __v_21: G = G::from_u64(180); + let __v_22: G = G::from_u64(235); + let __v_23: G = G::from_u64(99); + let __v_24: G = G::from_u64(157); + let __v_25: G = G::from_u64(187); + let __v_26: G = G::from_u64(171); + let __v_27: G = G::from_u64(162); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(239); + let __v_30: G = G::from_u64(43); + let __v_31: G = G::from_u64(248); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_155] = [__v_32]; record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16146,9 +16630,10 @@ fn aiur_fn_156( let __v_29: G = G::from_u64(240); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(98); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_156] = [__v_32]; record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16195,9 +16680,10 @@ fn aiur_fn_157( let __v_29: G = G::from_u64(244); let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_157] = [__v_32]; record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16212,41 +16698,42 @@ fn aiur_fn_158( unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(169); - let __v_1: G = G::from_u64(22); - let __v_2: G = G::from_u64(36); - let __v_3: G = G::from_u64(68); - let __v_4: G = G::from_u64(83); - let __v_5: G = G::from_u64(147); - let __v_6: G = G::from_u64(166); - let __v_7: G = G::from_u64(116); - let __v_8: G = G::from_u64(250); - let __v_9: G = G::from_u64(15); - let __v_10: G = G::from_u64(158); - let __v_11: G = G::from_u64(159); - let __v_12: G = G::from_u64(154); - let __v_13: G = G::from_u64(82); - let __v_14: G = G::from_u64(244); - let __v_15: G = G::from_u64(27); - let __v_16: G = G::from_u64(147); - let __v_17: G = G::from_u64(177); - let __v_18: G = G::from_u64(4); - let __v_19: G = G::from_u64(135); - let __v_20: G = G::from_u64(1); - let __v_21: G = G::from_u64(128); - let __v_22: G = G::from_u64(70); - let __v_23: G = G::from_u64(203); - let __v_24: G = G::from_u64(193); - let __v_25: G = G::from_u64(38); - let __v_26: G = G::from_u64(90); - let __v_27: G = G::from_u64(36); - let __v_28: G = G::from_u64(85); - let __v_29: G = G::from_u64(188); - let __v_30: G = G::from_u64(250); - let __v_31: G = G::from_u64(236); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(207); + let __v_1: G = G::from_u64(134); + let __v_2: G = G::from_u64(38); + let __v_3: G = G::from_u64(53); + let __v_4: G = G::from_u64(33); + let __v_5: G = G::from_u64(211); + let __v_6: G = G::from_u64(69); + let __v_7: G = G::from_u64(195); + let __v_8: G = G::from_u64(144); + let __v_9: G = G::from_u64(118); + let __v_10: G = G::from_u64(71); + let __v_11: G = G::from_u64(62); + let __v_12: G = G::from_u64(205); + let __v_13: G = G::from_u64(185); + let __v_14: G = G::from_u64(246); + let __v_15: G = G::from_u64(253); + let __v_16: G = G::from_u64(65); + let __v_17: G = G::from_u64(27); + let __v_18: G = G::from_u64(91); + let __v_19: G = G::from_u64(80); + let __v_20: G = G::from_u64(59); + let __v_21: G = G::from_u64(206); + let __v_22: G = G::from_u64(131); + let __v_23: G = G::from_u64(226); + let __v_24: G = G::from_u64(49); + let __v_25: G = G::from_u64(139); + let __v_26: G = G::from_u64(163); + let __v_27: G = G::from_u64(251); + let __v_28: G = G::from_u64(111); + let __v_29: G = G::from_u64(35); + let __v_30: G = G::from_u64(118); + let __v_31: G = G::from_u64(216); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_158] = [__v_32]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16293,9 +16780,10 @@ fn aiur_fn_159( let __v_29: G = G::from_u64(127); let __v_30: G = G::from_u64(64); let __v_31: G = G::from_u64(18); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_159] = [__v_32]; record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16342,9 +16830,10 @@ fn aiur_fn_160( let __v_29: G = G::from_u64(169); let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(120); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_160] = [__v_32]; record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16391,9 +16880,10 @@ fn aiur_fn_161( let __v_29: G = G::from_u64(40); let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(96); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_161] = [__v_32]; record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16408,41 +16898,42 @@ fn aiur_fn_162( unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(12); - let __v_1: G = G::from_u64(112); - let __v_2: G = G::from_u64(114); - let __v_3: G = G::from_u64(169); - let __v_4: G = G::from_u64(39); - let __v_5: G = G::from_u64(177); - let __v_6: G = G::from_u64(196); - let __v_7: G = G::from_u64(110); - let __v_8: G = G::from_u64(252); - let __v_9: G = G::from_u64(148); - let __v_10: G = G::from_u64(152); - let __v_11: G = G::from_u64(231); - let __v_12: G = G::from_u64(73); - let __v_13: G = G::from_u64(184); - let __v_14: G = G::from_u64(50); - let __v_15: G = G::from_u64(11); - let __v_16: G = G::from_u64(116); - let __v_17: G = G::from_u64(216); - let __v_18: G = G::from_u64(153); - let __v_19: G = G::from_u64(78); - let __v_20: G = G::from_u64(194); - let __v_21: G = G::from_u64(128); - let __v_22: G = G::from_u64(96); - let __v_23: G = G::from_u64(22); - let __v_24: G = G::from_u64(40); - let __v_25: G = G::from_u64(191); - let __v_26: G = G::from_u64(174); - let __v_27: G = G::from_u64(225); - let __v_28: G = G::from_u64(173); - let __v_29: G = G::from_u64(227); - let __v_30: G = G::from_u64(108); - let __v_31: G = G::from_u64(113); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(11); + let __v_1: G = G::from_u64(89); + let __v_2: G = G::from_u64(88); + let __v_3: G = G::from_u64(163); + let __v_4: G = G::from_u64(200); + let __v_5: G = G::from_u64(34); + let __v_6: G = G::from_u64(201); + let __v_7: G = G::from_u64(158); + let __v_8: G = G::from_u64(134); + let __v_9: G = G::from_u64(67); + let __v_10: G = G::from_u64(162); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(11); + let __v_13: G = G::from_u64(146); + let __v_14: G = G::from_u64(141); + let __v_15: G = G::from_u64(251); + let __v_16: G = G::from_u64(130); + let __v_17: G = G::from_u64(196); + let __v_18: G = G::from_u64(84); + let __v_19: G = G::from_u64(71); + let __v_20: G = G::from_u64(190); + let __v_21: G = G::from_u64(224); + let __v_22: G = G::from_u64(53); + let __v_23: G = G::from_u64(60); + let __v_24: G = G::from_u64(32); + let __v_25: G = G::from_u64(10); + let __v_26: G = G::from_u64(209); + let __v_27: G = G::from_u64(183); + let __v_28: G = G::from_u64(208); + let __v_29: G = G::from_u64(228); + let __v_30: G = G::from_u64(96); + let __v_31: G = G::from_u64(146); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_162] = [__v_32]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16457,41 +16948,42 @@ fn aiur_fn_163( unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(102); - let __v_1: G = G::from_u64(242); - let __v_2: G = G::from_u64(155); - let __v_3: G = G::from_u64(230); - let __v_4: G = G::from_u64(224); - let __v_5: G = G::from_u64(10); - let __v_6: G = G::from_u64(200); - let __v_7: G = G::from_u64(53); - let __v_8: G = G::from_u64(99); - let __v_9: G = G::from_u64(138); - let __v_10: G = G::from_u64(40); - let __v_11: G = G::from_u64(20); - let __v_12: G = G::from_u64(152); - let __v_13: G = G::from_u64(143); - let __v_14: G = G::from_u64(156); - let __v_15: G = G::from_u64(241); - let __v_16: G = G::from_u64(101); - let __v_17: G = G::from_u64(71); - let __v_18: G = G::from_u64(190); - let __v_19: G = G::from_u64(187); - let __v_20: G = G::from_u64(7); - let __v_21: G = G::from_u64(99); - let __v_22: G = G::from_u64(82); - let __v_23: G = G::from_u64(124); - let __v_24: G = G::from_u64(17); - let __v_25: G = G::from_u64(155); - let __v_26: G = G::from_u64(202); - let __v_27: G = G::from_u64(81); - let __v_28: G = G::from_u64(215); - let __v_29: G = G::from_u64(176); - let __v_30: G = G::from_u64(189); - let __v_31: G = G::from_u64(213); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(245); + let __v_1: G = G::from_u64(210); + let __v_2: G = G::from_u64(86); + let __v_3: G = G::from_u64(193); + let __v_4: G = G::from_u64(221); + let __v_5: G = G::from_u64(121); + let __v_6: G = G::from_u64(77); + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(207); + let __v_9: G = G::from_u64(223); + let __v_10: G = G::from_u64(23); + let __v_11: G = G::from_u64(98); + let __v_12: G = G::from_u64(201); + let __v_13: G = G::from_u64(228); + let __v_14: G = G::from_u64(27); + let __v_15: G = G::from_u64(19); + let __v_16: G = G::from_u64(171); + let __v_17: G = G::from_u64(229); + let __v_18: G = G::from_u64(189); + let __v_19: G = G::from_u64(221); + let __v_20: G = G::from_u64(225); + let __v_21: G = G::from_u64(45); + let __v_22: G = G::from_u64(146); + let __v_23: G = G::from_u64(157); + let __v_24: G = G::from_u64(2); + let __v_25: G = G::from_u64(173); + let __v_26: G = G::from_u64(163); + let __v_27: G = G::from_u64(126); + let __v_28: G = G::from_u64(79); + let __v_29: G = G::from_u64(64); + let __v_30: G = G::from_u64(232); + let __v_31: G = G::from_u64(95); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_163] = [__v_32]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16506,41 +16998,42 @@ fn aiur_fn_164( unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(163); - let __v_1: G = G::from_u64(67); - let __v_2: G = G::from_u64(166); - let __v_3: G = G::from_u64(81); - let __v_4: G = G::from_u64(191); - let __v_5: G = G::from_u64(244); - let __v_6: G = G::from_u64(8); - let __v_7: G = G::from_u64(195); - let __v_8: G = G::from_u64(162); - let __v_9: G = G::from_u64(159); - let __v_10: G = G::from_u64(242); - let __v_11: G = G::from_u64(123); - let __v_12: G = G::from_u64(43); - let __v_13: G = G::from_u64(98); - let __v_14: G = G::from_u64(227); - let __v_15: G = G::from_u64(75); - let __v_16: G = G::from_u64(84); - let __v_17: G = G::from_u64(178); - let __v_18: G = G::from_u64(171); - let __v_19: G = G::from_u64(56); - let __v_20: G = G::from_u64(28); - let __v_21: G = G::from_u64(246); - let __v_22: G = G::from_u64(243); - let __v_23: G = G::from_u64(173); - let __v_24: G = G::from_u64(135); - let __v_25: G = G::from_u64(197); - let __v_26: G = G::from_u64(64); - let __v_27: G = G::from_u64(201); - let __v_28: G = G::from_u64(119); - let __v_29: G = G::from_u64(220); - let __v_30: G = G::from_u64(60); - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(56); + let __v_1: G = G::from_u64(151); + let __v_2: G = G::from_u64(21); + let __v_3: G = G::from_u64(249); + let __v_4: G = G::from_u64(30); + let __v_5: G = G::from_u64(102); + let __v_6: G = G::from_u64(104); + let __v_7: G = G::from_u64(61); + let __v_8: G = G::from_u64(199); + let __v_9: G = G::from_u64(16); + let __v_10: G = G::from_u64(140); + let __v_11: G = G::from_u64(205); + let __v_12: G = G::from_u64(133); + let __v_13: G = G::from_u64(62); + let __v_14: G = G::from_u64(252); + let __v_15: G = G::from_u64(233); + let __v_16: G = G::from_u64(41); + let __v_17: G = G::from_u64(73); + let __v_18: G = G::from_u64(81); + let __v_19: G = G::from_u64(47); + let __v_20: G = G::from_u64(166); + let __v_21: G = G::from_u64(89); + let __v_22: G = G::from_u64(173); + let __v_23: G = G::from_u64(60); + let __v_24: G = G::from_u64(25); + let __v_25: G = G::from_u64(2); + let __v_26: G = G::from_u64(231); + let __v_27: G = G::from_u64(84); + let __v_28: G = G::from_u64(105); + let __v_29: G = G::from_u64(41); + let __v_30: G = G::from_u64(25); + let __v_31: G = G::from_u64(205); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_164] = [__v_32]; record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16587,9 +17080,10 @@ fn aiur_fn_165( let __v_29: G = G::from_u64(118); let __v_30: G = G::from_u64(105); let __v_31: G = G::from_u64(91); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_165] = [__v_32]; record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16636,9 +17130,10 @@ fn aiur_fn_166( let __v_29: G = G::from_u64(113); let __v_30: G = G::from_u64(15); let __v_31: G = G::from_u64(235); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_166] = [__v_32]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16663,6 +17158,7 @@ fn aiur_fn_167( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_3]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16675,6 +17171,7 @@ fn aiur_fn_167( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_5]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16687,6 +17184,7 @@ fn aiur_fn_167( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_7]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16699,6 +17197,7 @@ fn aiur_fn_167( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_9]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16711,6 +17210,7 @@ fn aiur_fn_167( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_11]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16723,12 +17223,14 @@ fn aiur_fn_167( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_13]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_167] = [__v_13]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16766,14 +17268,15 @@ fn aiur_fn_168( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_168] = [__v_16]; record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16799,14 +17302,15 @@ fn aiur_fn_169( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_169] = [__v_16]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16835,6 +17339,7 @@ fn aiur_fn_170( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_5, __v_6]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16849,6 +17354,7 @@ fn aiur_fn_170( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_7, __v_8]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16863,6 +17369,7 @@ fn aiur_fn_170( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_9, __v_10]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16877,6 +17384,7 @@ fn aiur_fn_170( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_11, __v_12]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16895,13 +17403,14 @@ fn aiur_fn_170( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_170] = [__v_16, __v_20]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __v_18: G = { let __a_val = __v_16.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 }; @@ -16911,16 +17420,17 @@ fn aiur_fn_170( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_170] = [__v_19, __v_23]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -16929,6 +17439,7 @@ fn aiur_fn_170( let __v_23: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_22, __v_23]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16937,6 +17448,7 @@ fn aiur_fn_170( let __v_23: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_22, __v_23]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16966,7 +17478,7 @@ fn aiur_fn_171( ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -16976,14 +17488,15 @@ fn aiur_fn_171( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_171] = [__v_4, __v_8]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -17006,6 +17519,7 @@ fn aiur_fn_171( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_14, __v_15]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17013,9 +17527,10 @@ fn aiur_fn_171( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_171] = [__v_14, __v_18]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17025,9 +17540,10 @@ fn aiur_fn_171( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_171] = [__v_12, __v_16]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17047,7 +17563,7 @@ fn aiur_fn_172( ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17057,14 +17573,15 @@ fn aiur_fn_172( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_172] = [__v_4, __v_8]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -17087,6 +17604,7 @@ fn aiur_fn_172( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_14, __v_15]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17101,6 +17619,7 @@ fn aiur_fn_172( let __v_17: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_16, __v_17]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17108,9 +17627,10 @@ fn aiur_fn_172( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_172] = [__v_16, __v_20]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17122,9 +17642,10 @@ fn aiur_fn_172( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_172] = [__v_12, __v_16]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17166,15 +17687,17 @@ fn aiur_fn_173( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_173] = [__v_10, __v_14]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_173] = [__v_10, __v_0]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17184,9 +17707,10 @@ fn aiur_fn_173( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_173] = [__v_5, __v_9]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17216,6 +17740,7 @@ fn aiur_fn_174( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_174] = [__v_5, __v_0]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17223,9 +17748,10 @@ fn aiur_fn_174( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_174] = [__v_5, __v_9]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17235,9 +17761,10 @@ fn aiur_fn_174( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_174] = [__v_5, __v_9]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17254,41 +17781,42 @@ fn aiur_fn_175( unconstrained: bool, ) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(152); - let __v_1: G = G::from_u64(107); - let __v_2: G = G::from_u64(156); - let __v_3: G = G::from_u64(115); - let __v_4: G = G::from_u64(108); - let __v_5: G = G::from_u64(185); - let __v_6: G = G::from_u64(48); - let __v_7: G = G::from_u64(200); - let __v_8: G = G::from_u64(28); - let __v_9: G = G::from_u64(174); - let __v_10: G = G::from_u64(105); - let __v_11: G = G::from_u64(126); - let __v_12: G = G::from_u64(196); - let __v_13: G = G::from_u64(150); - let __v_14: G = G::from_u64(128); - let __v_15: G = G::from_u64(75); - let __v_16: G = G::from_u64(110); - let __v_17: G = G::from_u64(68); - let __v_18: G = G::from_u64(21); - let __v_19: G = G::from_u64(161); - let __v_20: G = G::from_u64(120); - let __v_21: G = G::from_u64(228); - let __v_22: G = G::from_u64(240); - let __v_23: G = G::from_u64(2); - let __v_24: G = G::from_u64(47); - let __v_25: G = G::from_u64(176); - let __v_26: G = G::from_u64(88); - let __v_27: G = G::from_u64(245); - let __v_28: G = G::from_u64(3); - let __v_29: G = G::from_u64(74); - let __v_30: G = G::from_u64(183); - let __v_31: G = G::from_u64(191); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(119); + let __v_1: G = G::from_u64(160); + let __v_2: G = G::from_u64(37); + let __v_3: G = G::from_u64(193); + let __v_4: G = G::from_u64(159); + let __v_5: G = G::from_u64(139); + let __v_6: G = G::from_u64(225); + let __v_7: G = G::from_u64(49); + let __v_8: G = G::from_u64(251); + let __v_9: G = G::from_u64(157); + let __v_10: G = G::from_u64(91); + let __v_11: G = G::from_u64(11); + let __v_12: G = G::from_u64(236); + let __v_13: G = G::from_u64(73); + let __v_14: G = G::from_u64(72); + let __v_15: G = G::from_u64(23); + let __v_16: G = G::from_u64(162); + let __v_17: G = G::from_u64(101); + let __v_18: G = G::from_u64(56); + let __v_19: G = G::from_u64(185); + let __v_20: G = G::from_u64(165); + let __v_21: G = G::from_u64(80); + let __v_22: G = G::from_u64(171); + let __v_23: G = G::from_u64(187); + let __v_24: G = G::from_u64(206); + let __v_25: G = G::from_u64(200); + let __v_26: G = G::from_u64(9); + let __v_27: G = G::from_u64(159); + let __v_28: G = G::from_u64(174); + let __v_29: G = G::from_u64(157); + let __v_30: G = G::from_u64(228); + let __v_31: G = G::from_u64(228); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_175] = [__v_32]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17303,41 +17831,42 @@ fn aiur_fn_176( unconstrained: bool, ) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(218); - let __v_1: G = G::from_u64(8); - let __v_2: G = G::from_u64(47); - let __v_3: G = G::from_u64(21); - let __v_4: G = G::from_u64(125); - let __v_5: G = G::from_u64(42); - let __v_6: G = G::from_u64(123); - let __v_7: G = G::from_u64(134); - let __v_8: G = G::from_u64(235); - let __v_9: G = G::from_u64(34); - let __v_10: G = G::from_u64(107); - let __v_11: G = G::from_u64(24); - let __v_12: G = G::from_u64(129); - let __v_13: G = G::from_u64(191); - let __v_14: G = G::from_u64(172); - let __v_15: G = G::from_u64(208); - let __v_16: G = G::from_u64(217); - let __v_17: G = G::from_u64(221); - let __v_18: G = G::from_u64(27); - let __v_19: G = G::from_u64(225); - let __v_20: G = G::from_u64(122); - let __v_21: G = G::from_u64(39); - let __v_22: G = G::from_u64(225); - let __v_23: G = G::from_u64(63); - let __v_24: G = G::from_u64(163); - let __v_25: G = G::from_u64(0); - let __v_26: G = G::from_u64(192); - let __v_27: G = G::from_u64(21); - let __v_28: G = G::from_u64(196); - let __v_29: G = G::from_u64(255); - let __v_30: G = G::from_u64(191); - let __v_31: G = G::from_u64(133); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(144); + let __v_1: G = G::from_u64(202); + let __v_2: G = G::from_u64(129); + let __v_3: G = G::from_u64(48); + let __v_4: G = G::from_u64(115); + let __v_5: G = G::from_u64(92); + let __v_6: G = G::from_u64(141); + let __v_7: G = G::from_u64(154); + let __v_8: G = G::from_u64(52); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(90); + let __v_11: G = G::from_u64(137); + let __v_12: G = G::from_u64(67); + let __v_13: G = G::from_u64(181); + let __v_14: G = G::from_u64(159); + let __v_15: G = G::from_u64(225); + let __v_16: G = G::from_u64(223); + let __v_17: G = G::from_u64(24); + let __v_18: G = G::from_u64(46); + let __v_19: G = G::from_u64(8); + let __v_20: G = G::from_u64(169); + let __v_21: G = G::from_u64(242); + let __v_22: G = G::from_u64(191); + let __v_23: G = G::from_u64(199); + let __v_24: G = G::from_u64(220); + let __v_25: G = G::from_u64(131); + let __v_26: G = G::from_u64(35); + let __v_27: G = G::from_u64(34); + let __v_28: G = G::from_u64(150); + let __v_29: G = G::from_u64(89); + let __v_30: G = G::from_u64(165); + let __v_31: G = G::from_u64(116); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_176] = [__v_32]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17352,41 +17881,42 @@ fn aiur_fn_177( unconstrained: bool, ) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(234); - let __v_1: G = G::from_u64(253); - let __v_2: G = G::from_u64(27); - let __v_3: G = G::from_u64(47); - let __v_4: G = G::from_u64(107); - let __v_5: G = G::from_u64(87); - let __v_6: G = G::from_u64(26); - let __v_7: G = G::from_u64(191); - let __v_8: G = G::from_u64(118); - let __v_9: G = G::from_u64(174); - let __v_10: G = G::from_u64(150); - let __v_11: G = G::from_u64(234); - let __v_12: G = G::from_u64(249); - let __v_13: G = G::from_u64(196); - let __v_14: G = G::from_u64(133); - let __v_15: G = G::from_u64(42); - let __v_16: G = G::from_u64(164); - let __v_17: G = G::from_u64(82); - let __v_18: G = G::from_u64(13); - let __v_19: G = G::from_u64(6); - let __v_20: G = G::from_u64(223); - let __v_21: G = G::from_u64(83); - let __v_22: G = G::from_u64(66); - let __v_23: G = G::from_u64(145); - let __v_24: G = G::from_u64(89); - let __v_25: G = G::from_u64(10); - let __v_26: G = G::from_u64(113); - let __v_27: G = G::from_u64(162); - let __v_28: G = G::from_u64(30); - let __v_29: G = G::from_u64(111); - let __v_30: G = G::from_u64(11); - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(105); + let __v_1: G = G::from_u64(141); + let __v_2: G = G::from_u64(213); + let __v_3: G = G::from_u64(147); + let __v_4: G = G::from_u64(171); + let __v_5: G = G::from_u64(251); + let __v_6: G = G::from_u64(99); + let __v_7: G = G::from_u64(219); + let __v_8: G = G::from_u64(54); + let __v_9: G = G::from_u64(42); + let __v_10: G = G::from_u64(174); + let __v_11: G = G::from_u64(245); + let __v_12: G = G::from_u64(126); + let __v_13: G = G::from_u64(112); + let __v_14: G = G::from_u64(167); + let __v_15: G = G::from_u64(147); + let __v_16: G = G::from_u64(4); + let __v_17: G = G::from_u64(79); + let __v_18: G = G::from_u64(182); + let __v_19: G = G::from_u64(87); + let __v_20: G = G::from_u64(37); + let __v_21: G = G::from_u64(114); + let __v_22: G = G::from_u64(145); + let __v_23: G = G::from_u64(238); + let __v_24: G = G::from_u64(44); + let __v_25: G = G::from_u64(62); + let __v_26: G = G::from_u64(153); + let __v_27: G = G::from_u64(124); + let __v_28: G = G::from_u64(170); + let __v_29: G = G::from_u64(66); + let __v_30: G = G::from_u64(62); + let __v_31: G = G::from_u64(174); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_177] = [__v_32]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17401,41 +17931,42 @@ fn aiur_fn_178( unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(182); - let __v_1: G = G::from_u64(104); - let __v_2: G = G::from_u64(219); - let __v_3: G = G::from_u64(125); - let __v_4: G = G::from_u64(18); - let __v_5: G = G::from_u64(202); - let __v_6: G = G::from_u64(187); - let __v_7: G = G::from_u64(77); - let __v_8: G = G::from_u64(127); - let __v_9: G = G::from_u64(226); - let __v_10: G = G::from_u64(225); - let __v_11: G = G::from_u64(175); - let __v_12: G = G::from_u64(37); - let __v_13: G = G::from_u64(152); - let __v_14: G = G::from_u64(75); - let __v_15: G = G::from_u64(170); - let __v_16: G = G::from_u64(40); - let __v_17: G = G::from_u64(187); - let __v_18: G = G::from_u64(40); - let __v_19: G = G::from_u64(82); - let __v_20: G = G::from_u64(169); - let __v_21: G = G::from_u64(130); - let __v_22: G = G::from_u64(218); - let __v_23: G = G::from_u64(141); - let __v_24: G = G::from_u64(84); - let __v_25: G = G::from_u64(148); - let __v_26: G = G::from_u64(43); - let __v_27: G = G::from_u64(179); - let __v_28: G = G::from_u64(68); - let __v_29: G = G::from_u64(114); - let __v_30: G = G::from_u64(108); - let __v_31: G = G::from_u64(207); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(159); + let __v_1: G = G::from_u64(216); + let __v_2: G = G::from_u64(231); + let __v_3: G = G::from_u64(69); + let __v_4: G = G::from_u64(154); + let __v_5: G = G::from_u64(29); + let __v_6: G = G::from_u64(45); + let __v_7: G = G::from_u64(238); + let __v_8: G = G::from_u64(240); + let __v_9: G = G::from_u64(10); + let __v_10: G = G::from_u64(73); + let __v_11: G = G::from_u64(146); + let __v_12: G = G::from_u64(165); + let __v_13: G = G::from_u64(4); + let __v_14: G = G::from_u64(25); + let __v_15: G = G::from_u64(186); + let __v_16: G = G::from_u64(198); + let __v_17: G = G::from_u64(108); + let __v_18: G = G::from_u64(3); + let __v_19: G = G::from_u64(8); + let __v_20: G = G::from_u64(43); + let __v_21: G = G::from_u64(88); + let __v_22: G = G::from_u64(173); + let __v_23: G = G::from_u64(224); + let __v_24: G = G::from_u64(116); + let __v_25: G = G::from_u64(34); + let __v_26: G = G::from_u64(137); + let __v_27: G = G::from_u64(111); + let __v_28: G = G::from_u64(19); + let __v_29: G = G::from_u64(3); + let __v_30: G = G::from_u64(61); + let __v_31: G = G::from_u64(116); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_178] = [__v_32]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17482,9 +18013,10 @@ fn aiur_fn_179( let __v_29: G = G::from_u64(115); let __v_30: G = G::from_u64(55); let __v_31: G = G::from_u64(35); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_179] = [__v_32]; record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17531,9 +18063,10 @@ fn aiur_fn_180( let __v_29: G = G::from_u64(61); let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(18); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_180] = [__v_32]; record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17558,6 +18091,7 @@ fn aiur_fn_181( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_181] = [__v_3]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17570,6 +18104,7 @@ fn aiur_fn_181( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_181] = [__v_5]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17582,12 +18117,14 @@ fn aiur_fn_181( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_181] = [__v_7]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_181] = [__v_7]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17616,11 +18153,12 @@ fn aiur_fn_182( let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_182] = [__v_7]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17629,11 +18167,12 @@ fn aiur_fn_182( let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_182] = [__v_7]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17661,9 +18200,10 @@ fn aiur_fn_183( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_183] = [__v_5, __v_8]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -17675,9 +18215,10 @@ fn aiur_fn_183( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_183] = [__v_7, __v_10]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -17689,9 +18230,10 @@ fn aiur_fn_183( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_183] = [__v_9, __v_12]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -17706,8 +18248,8 @@ fn aiur_fn_183( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); @@ -17717,6 +18259,7 @@ fn aiur_fn_183( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_23, __v_25]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17747,7 +18290,7 @@ fn aiur_fn_184( ) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17757,20 +18300,21 @@ fn aiur_fn_184( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_184] = [__v_4, __v_8]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -17781,9 +18325,10 @@ fn aiur_fn_184( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_184] = [__v_12, __v_16]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -17796,9 +18341,10 @@ fn aiur_fn_184( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_184] = [__v_14, __v_18]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -17811,6 +18357,7 @@ fn aiur_fn_184( let __v_18: G = __r_arr[0]; let __ret: [G; OUT_184] = [__v_17, __v_18]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17838,7 +18385,7 @@ fn aiur_fn_185( ) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17848,14 +18395,15 @@ fn aiur_fn_185( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_185] = [__v_4, __v_8]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -17877,13 +18425,14 @@ fn aiur_fn_185( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_185] = [__v_14, __v_18]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17893,14 +18442,15 @@ fn aiur_fn_185( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_185] = [__v_17, __v_21]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -17922,13 +18472,14 @@ fn aiur_fn_185( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_185] = [__v_27, __v_31]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17938,35 +18489,37 @@ fn aiur_fn_185( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_185] = [__v_30, __v_34]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = G::from_u64(1); - let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __ret: [G; OUT_185] = [__v_45, __v_46]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17978,9 +18531,10 @@ fn aiur_fn_185( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_185] = [__v_25, __v_29]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17994,9 +18548,10 @@ fn aiur_fn_185( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_185] = [__v_12, __v_16]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18032,7 +18587,7 @@ fn aiur_fn_186( let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -18040,13 +18595,14 @@ fn aiur_fn_186( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_186] = [__v_12, __v_14, __v_16]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18054,13 +18610,14 @@ fn aiur_fn_186( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_186] = [__v_12, __v_16, __v_20]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18070,13 +18627,14 @@ fn aiur_fn_186( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_186] = [__v_9, __v_13, __v_17]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18086,13 +18644,14 @@ fn aiur_fn_186( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_186] = [__v_7, __v_11, __v_15]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18118,7 +18677,7 @@ fn aiur_fn_187( let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -18128,19 +18687,20 @@ fn aiur_fn_187( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_187] = [__v_8, __v_12]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -18151,9 +18711,10 @@ fn aiur_fn_187( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_187] = [__v_15, __v_19]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -18162,6 +18723,7 @@ fn aiur_fn_187( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_187] = [__v_15, __v_16]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18185,6 +18747,7 @@ fn aiur_fn_187( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_187] = [__v_8, __v_9]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18199,6 +18762,7 @@ fn aiur_fn_187( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_187] = [__v_9, __v_10]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18206,9 +18770,10 @@ fn aiur_fn_187( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_187] = [__v_9, __v_13]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18231,7 +18796,7 @@ fn aiur_fn_188( 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_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -18241,6 +18806,7 @@ fn aiur_fn_188( 1u64 => { let __ret: [G; OUT_188] = [__v_2]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -18252,6 +18818,7 @@ fn aiur_fn_188( 1u64 => { let __ret: [G; OUT_188] = [__v_2]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -18263,6 +18830,7 @@ fn aiur_fn_188( 1u64 => { let __ret: [G; OUT_188] = [__v_2]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -18273,11 +18841,12 @@ fn aiur_fn_188( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_188] = [__v_19]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18312,12 +18881,13 @@ fn aiur_fn_189( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_189] = [__v_5]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18332,41 +18902,42 @@ fn aiur_fn_190( unconstrained: bool, ) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(106); - let __v_1: G = G::from_u64(20); - let __v_2: G = G::from_u64(45); - let __v_3: G = G::from_u64(145); - let __v_4: G = G::from_u64(232); - let __v_5: G = G::from_u64(119); - let __v_6: G = G::from_u64(149); - let __v_7: G = G::from_u64(158); - let __v_8: G = G::from_u64(20); - let __v_9: G = G::from_u64(25); - let __v_10: G = G::from_u64(195); - let __v_11: G = G::from_u64(69); - let __v_12: G = G::from_u64(128); - let __v_13: G = G::from_u64(138); - let __v_14: G = G::from_u64(121); - let __v_15: G = G::from_u64(163); - let __v_16: G = G::from_u64(233); - let __v_17: G = G::from_u64(88); - let __v_18: G = G::from_u64(24); - let __v_19: G = G::from_u64(87); - let __v_20: G = G::from_u64(122); - let __v_21: G = G::from_u64(253); - let __v_22: G = G::from_u64(166); - let __v_23: G = G::from_u64(141); - let __v_24: G = G::from_u64(40); - let __v_25: G = G::from_u64(127); - let __v_26: G = G::from_u64(79); - let __v_27: G = G::from_u64(136); - let __v_28: G = G::from_u64(21); - let __v_29: G = G::from_u64(33); - let __v_30: G = G::from_u64(221); - let __v_31: G = G::from_u64(233); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(222); + let __v_1: G = G::from_u64(244); + let __v_2: G = G::from_u64(67); + let __v_3: G = G::from_u64(61); + let __v_4: G = G::from_u64(149); + let __v_5: G = G::from_u64(71); + let __v_6: G = G::from_u64(181); + let __v_7: G = G::from_u64(49); + let __v_8: G = G::from_u64(117); + let __v_9: G = G::from_u64(226); + let __v_10: G = G::from_u64(74); + let __v_11: G = G::from_u64(58); + let __v_12: G = G::from_u64(193); + let __v_13: G = G::from_u64(130); + let __v_14: G = G::from_u64(200); + let __v_15: G = G::from_u64(139); + let __v_16: G = G::from_u64(7); + let __v_17: G = G::from_u64(42); + let __v_18: G = G::from_u64(240); + let __v_19: G = G::from_u64(212); + let __v_20: G = G::from_u64(173); + let __v_21: G = G::from_u64(51); + let __v_22: G = G::from_u64(253); + let __v_23: G = G::from_u64(4); + let __v_24: G = G::from_u64(236); + let __v_25: G = G::from_u64(76); + let __v_26: G = G::from_u64(242); + let __v_27: G = G::from_u64(186); + let __v_28: G = G::from_u64(61); + let __v_29: G = G::from_u64(149); + let __v_30: G = G::from_u64(234); + let __v_31: G = G::from_u64(147); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_190] = [__v_32]; record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18381,41 +18952,42 @@ fn aiur_fn_191( unconstrained: bool, ) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(56); - let __v_1: G = G::from_u64(3); - let __v_2: G = G::from_u64(173); - let __v_3: G = G::from_u64(194); - let __v_4: G = G::from_u64(29); - let __v_5: G = G::from_u64(137); - let __v_6: G = G::from_u64(150); - let __v_7: G = G::from_u64(147); - let __v_8: G = G::from_u64(161); - let __v_9: G = G::from_u64(73); - let __v_10: G = G::from_u64(29); - let __v_11: G = G::from_u64(176); - let __v_12: G = G::from_u64(84); - let __v_13: G = G::from_u64(16); - let __v_14: G = G::from_u64(75); - let __v_15: G = G::from_u64(32); - let __v_16: G = G::from_u64(189); - let __v_17: G = G::from_u64(64); - let __v_18: G = G::from_u64(252); - let __v_19: G = G::from_u64(12); - let __v_20: G = G::from_u64(161); - let __v_21: G = G::from_u64(246); - let __v_22: G = G::from_u64(180); - let __v_23: G = G::from_u64(55); - let __v_24: G = G::from_u64(75); - let __v_25: G = G::from_u64(123); - let __v_26: G = G::from_u64(21); - let __v_27: G = G::from_u64(139); - let __v_28: G = G::from_u64(66); - let __v_29: G = G::from_u64(82); - let __v_30: G = G::from_u64(179); - let __v_31: G = G::from_u64(139); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(89); + let __v_1: G = G::from_u64(79); + let __v_2: G = G::from_u64(177); + let __v_3: G = G::from_u64(238); + let __v_4: G = G::from_u64(222); + let __v_5: G = G::from_u64(199); + let __v_6: G = G::from_u64(201); + let __v_7: G = G::from_u64(57); + let __v_8: G = G::from_u64(204); + let __v_9: G = G::from_u64(135); + let __v_10: G = G::from_u64(43); + let __v_11: G = G::from_u64(108); + let __v_12: G = G::from_u64(4); + let __v_13: G = G::from_u64(204); + let __v_14: G = G::from_u64(59); + let __v_15: G = G::from_u64(62); + let __v_16: G = G::from_u64(10); + let __v_17: G = G::from_u64(151); + let __v_18: G = G::from_u64(100); + let __v_19: G = G::from_u64(250); + let __v_20: G = G::from_u64(190); + let __v_21: G = G::from_u64(195); + let __v_22: G = G::from_u64(230); + let __v_23: G = G::from_u64(2); + let __v_24: G = G::from_u64(173); + let __v_25: G = G::from_u64(146); + let __v_26: G = G::from_u64(20); + let __v_27: G = G::from_u64(208); + let __v_28: G = G::from_u64(230); + let __v_29: G = G::from_u64(55); + let __v_30: G = G::from_u64(211); + let __v_31: G = G::from_u64(15); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_191] = [__v_32]; record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18430,41 +19002,42 @@ fn aiur_fn_192( unconstrained: bool, ) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(142); - let __v_1: G = G::from_u64(158); - let __v_2: G = G::from_u64(106); - let __v_3: G = G::from_u64(242); - let __v_4: G = G::from_u64(214); - let __v_5: G = G::from_u64(90); - let __v_6: G = G::from_u64(23); - let __v_7: G = G::from_u64(9); - let __v_8: G = G::from_u64(74); - let __v_9: G = G::from_u64(135); - let __v_10: G = G::from_u64(80); - let __v_11: G = G::from_u64(15); - let __v_12: G = G::from_u64(132); - let __v_13: G = G::from_u64(247); - let __v_14: G = G::from_u64(178); - let __v_15: G = G::from_u64(109); - let __v_16: G = G::from_u64(130); - let __v_17: G = G::from_u64(237); - let __v_18: G = G::from_u64(202); - let __v_19: G = G::from_u64(208); - let __v_20: G = G::from_u64(221); - let __v_21: G = G::from_u64(105); - let __v_22: G = G::from_u64(153); - let __v_23: G = G::from_u64(121); - let __v_24: G = G::from_u64(74); - let __v_25: G = G::from_u64(139); - let __v_26: G = G::from_u64(70); - let __v_27: G = G::from_u64(236); - let __v_28: G = G::from_u64(181); - let __v_29: G = G::from_u64(84); - let __v_30: G = G::from_u64(36); - let __v_31: G = G::from_u64(45); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(150); + let __v_1: G = G::from_u64(113); + let __v_2: G = G::from_u64(253); + let __v_3: G = G::from_u64(79); + let __v_4: G = G::from_u64(207); + let __v_5: G = G::from_u64(188); + let __v_6: G = G::from_u64(6); + let __v_7: G = G::from_u64(28); + let __v_8: G = G::from_u64(147); + let __v_9: G = G::from_u64(194); + let __v_10: G = G::from_u64(130); + let __v_11: G = G::from_u64(72); + let __v_12: G = G::from_u64(100); + let __v_13: G = G::from_u64(207); + let __v_14: G = G::from_u64(3); + let __v_15: G = G::from_u64(18); + let __v_16: G = G::from_u64(79); + let __v_17: G = G::from_u64(254); + let __v_18: G = G::from_u64(231); + let __v_19: G = G::from_u64(204); + let __v_20: G = G::from_u64(34); + let __v_21: G = G::from_u64(48); + let __v_22: G = G::from_u64(141); + let __v_23: G = G::from_u64(225); + let __v_24: G = G::from_u64(42); + let __v_25: G = G::from_u64(124); + let __v_26: G = G::from_u64(130); + let __v_27: G = G::from_u64(100); + let __v_28: G = G::from_u64(115); + let __v_29: G = G::from_u64(228); + let __v_30: G = G::from_u64(153); + let __v_31: G = G::from_u64(6); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_192] = [__v_32]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18479,41 +19052,42 @@ fn aiur_fn_193( unconstrained: bool, ) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(96); - let __v_1: G = G::from_u64(75); - let __v_2: G = G::from_u64(35); - let __v_3: G = G::from_u64(205); - let __v_4: G = G::from_u64(15); - let __v_5: G = G::from_u64(172); + let __v_0: G = G::from_u64(26); + let __v_1: G = G::from_u64(76); + let __v_2: G = G::from_u64(102); + let __v_3: G = G::from_u64(247); + let __v_4: G = G::from_u64(103); + let __v_5: G = G::from_u64(96); let __v_6: G = G::from_u64(245); - let __v_7: G = G::from_u64(179); - let __v_8: G = G::from_u64(229); + let __v_7: G = G::from_u64(239); + let __v_8: G = G::from_u64(56); let __v_9: G = G::from_u64(109); - let __v_10: G = G::from_u64(239); - let __v_11: G = G::from_u64(87); - let __v_12: G = G::from_u64(218); - let __v_13: G = G::from_u64(145); - let __v_14: G = G::from_u64(178); - let __v_15: G = G::from_u64(104); - let __v_16: G = G::from_u64(143); - let __v_17: G = G::from_u64(252); - let __v_18: G = G::from_u64(167); - let __v_19: G = G::from_u64(197); - let __v_20: G = G::from_u64(67); - let __v_21: G = G::from_u64(91); - let __v_22: G = G::from_u64(181); - let __v_23: G = G::from_u64(220); - let __v_24: G = G::from_u64(44); - let __v_25: G = G::from_u64(177); - let __v_26: G = G::from_u64(26); - let __v_27: G = G::from_u64(104); - let __v_28: G = G::from_u64(163); - let __v_29: G = G::from_u64(49); - let __v_30: G = G::from_u64(134); - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(224); + let __v_11: G = G::from_u64(137); + let __v_12: G = G::from_u64(104); + let __v_13: G = G::from_u64(42); + let __v_14: G = G::from_u64(85); + let __v_15: G = G::from_u64(183); + let __v_16: G = G::from_u64(82); + let __v_17: G = G::from_u64(19); + let __v_18: G = G::from_u64(30); + let __v_19: G = G::from_u64(20); + let __v_20: G = G::from_u64(160); + let __v_21: G = G::from_u64(133); + let __v_22: G = G::from_u64(87); + let __v_23: G = G::from_u64(196); + let __v_24: G = G::from_u64(70); + let __v_25: G = G::from_u64(94); + let __v_26: G = G::from_u64(209); + let __v_27: G = G::from_u64(127); + let __v_28: G = G::from_u64(224); + let __v_29: G = G::from_u64(196); + let __v_30: G = G::from_u64(220); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_193] = [__v_32]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18560,9 +19134,10 @@ fn aiur_fn_194( let __v_29: G = G::from_u64(239); let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(62); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_194] = [__v_32]; record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18609,9 +19184,10 @@ fn aiur_fn_195( let __v_29: G = G::from_u64(53); let __v_30: G = G::from_u64(2); let __v_31: G = G::from_u64(160); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_195] = [__v_32]; record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18626,41 +19202,42 @@ fn aiur_fn_196( unconstrained: bool, ) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(152); - let __v_1: G = G::from_u64(201); - let __v_2: G = G::from_u64(140); - let __v_3: G = G::from_u64(15); - let __v_4: G = G::from_u64(153); - let __v_5: G = G::from_u64(111); - let __v_6: G = G::from_u64(33); - let __v_7: G = G::from_u64(246); - let __v_8: G = G::from_u64(226); - let __v_9: G = G::from_u64(182); - let __v_10: G = G::from_u64(31); - let __v_11: G = G::from_u64(30); - let __v_12: G = G::from_u64(252); - let __v_13: G = G::from_u64(174); - let __v_14: G = G::from_u64(153); - let __v_15: G = G::from_u64(186); - let __v_16: G = G::from_u64(169); - let __v_17: G = G::from_u64(139); - let __v_18: G = G::from_u64(226); - let __v_19: G = G::from_u64(106); - let __v_20: G = G::from_u64(127); - let __v_21: G = G::from_u64(248); - let __v_22: G = G::from_u64(37); - let __v_23: G = G::from_u64(21); - let __v_24: G = G::from_u64(104); - let __v_25: G = G::from_u64(74); - let __v_26: G = G::from_u64(130); - let __v_27: G = G::from_u64(105); - let __v_28: G = G::from_u64(84); - let __v_29: G = G::from_u64(179); - let __v_30: G = G::from_u64(94); - let __v_31: G = G::from_u64(41); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(41); + let __v_1: G = G::from_u64(221); + let __v_2: G = G::from_u64(45); + let __v_3: G = G::from_u64(25); + let __v_4: G = G::from_u64(134); + let __v_5: G = G::from_u64(165); + let __v_6: G = G::from_u64(37); + let __v_7: G = G::from_u64(189); + let __v_8: G = G::from_u64(222); + let __v_9: G = G::from_u64(73); + let __v_10: G = G::from_u64(180); + let __v_11: G = G::from_u64(173); + let __v_12: G = G::from_u64(45); + let __v_13: G = G::from_u64(239); + let __v_14: G = G::from_u64(195); + let __v_15: G = G::from_u64(73); + let __v_16: G = G::from_u64(206); + let __v_17: G = G::from_u64(199); + let __v_18: G = G::from_u64(29); + let __v_19: G = G::from_u64(4); + let __v_20: G = G::from_u64(132); + let __v_21: G = G::from_u64(205); + let __v_22: G = G::from_u64(19); + let __v_23: G = G::from_u64(242); + let __v_24: G = G::from_u64(218); + let __v_25: G = G::from_u64(146); + let __v_26: G = G::from_u64(241); + let __v_27: G = G::from_u64(252); + let __v_28: G = G::from_u64(232); + let __v_29: G = G::from_u64(154); + let __v_30: G = G::from_u64(76); + let __v_31: G = G::from_u64(121); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_196] = [__v_32]; record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18675,41 +19252,42 @@ fn aiur_fn_197( unconstrained: bool, ) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(208); - let __v_1: G = G::from_u64(127); - let __v_2: G = G::from_u64(129); - let __v_3: G = G::from_u64(5); - let __v_4: G = G::from_u64(197); - let __v_5: G = G::from_u64(68); - let __v_6: G = G::from_u64(34); - let __v_7: G = G::from_u64(122); - let __v_8: G = G::from_u64(19); - let __v_9: G = G::from_u64(236); - let __v_10: G = G::from_u64(144); - let __v_11: G = G::from_u64(190); - let __v_12: G = G::from_u64(250); - let __v_13: G = G::from_u64(226); - let __v_14: G = G::from_u64(0); - let __v_15: G = G::from_u64(94); - let __v_16: G = G::from_u64(156); - let __v_17: G = G::from_u64(111); - let __v_18: G = G::from_u64(100); - let __v_19: G = G::from_u64(73); - let __v_20: G = G::from_u64(63); - let __v_21: G = G::from_u64(140); + let __v_0: G = G::from_u64(233); + let __v_1: G = G::from_u64(92); + let __v_2: G = G::from_u64(141); + let __v_3: G = G::from_u64(135); + let __v_4: G = G::from_u64(110); + let __v_5: G = G::from_u64(124); + let __v_6: G = G::from_u64(207); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(4); + let __v_9: G = G::from_u64(24); + let __v_10: G = G::from_u64(97); + let __v_11: G = G::from_u64(94); + let __v_12: G = G::from_u64(51); + let __v_13: G = G::from_u64(183); + let __v_14: G = G::from_u64(71); + let __v_15: G = G::from_u64(162); + let __v_16: G = G::from_u64(69); + let __v_17: G = G::from_u64(217); + let __v_18: G = G::from_u64(79); + let __v_19: G = G::from_u64(172); + let __v_20: G = G::from_u64(215); + let __v_21: G = G::from_u64(86); let __v_22: G = G::from_u64(127); - let __v_23: G = G::from_u64(246); - let __v_24: G = G::from_u64(105); - let __v_25: G = G::from_u64(186); - let __v_26: G = G::from_u64(116); - let __v_27: G = G::from_u64(62); - let __v_28: G = G::from_u64(21); - let __v_29: G = G::from_u64(71); - let __v_30: G = G::from_u64(201); - let __v_31: G = G::from_u64(53); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(236); + let __v_24: G = G::from_u64(190); + let __v_25: G = G::from_u64(122); + let __v_26: G = G::from_u64(231); + let __v_27: G = G::from_u64(58); + let __v_28: G = G::from_u64(90); + let __v_29: G = G::from_u64(192); + let __v_30: G = G::from_u64(146); + let __v_31: G = G::from_u64(6); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_197] = [__v_32]; record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18724,41 +19302,42 @@ fn aiur_fn_198( unconstrained: bool, ) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(252); - let __v_1: G = G::from_u64(73); - let __v_2: G = G::from_u64(53); - let __v_3: G = G::from_u64(122); - let __v_4: G = G::from_u64(91); - let __v_5: G = G::from_u64(198); - let __v_6: G = G::from_u64(82); - let __v_7: G = G::from_u64(88); - let __v_8: G = G::from_u64(57); - let __v_9: G = G::from_u64(167); - let __v_10: G = G::from_u64(188); - let __v_11: G = G::from_u64(17); - let __v_12: G = G::from_u64(185); - let __v_13: G = G::from_u64(223); - let __v_14: G = G::from_u64(32); - let __v_15: G = G::from_u64(120); - let __v_16: G = G::from_u64(82); - let __v_17: G = G::from_u64(166); - let __v_18: G = G::from_u64(233); - let __v_19: G = G::from_u64(198); - let __v_20: G = G::from_u64(175); - let __v_21: G = G::from_u64(163); - let __v_22: G = G::from_u64(236); - let __v_23: G = G::from_u64(98); - let __v_24: G = G::from_u64(186); - let __v_25: G = G::from_u64(195); - let __v_26: G = G::from_u64(197); - let __v_27: G = G::from_u64(66); - let __v_28: G = G::from_u64(172); - let __v_29: G = G::from_u64(137); - let __v_30: G = G::from_u64(224); - let __v_31: G = G::from_u64(224); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(107); + let __v_1: G = G::from_u64(182); + let __v_2: G = G::from_u64(22); + let __v_3: G = G::from_u64(42); + let __v_4: G = G::from_u64(172); + let __v_5: G = G::from_u64(125); + let __v_6: G = G::from_u64(106); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(182); + let __v_9: G = G::from_u64(236); + let __v_10: G = G::from_u64(5); + let __v_11: G = G::from_u64(88); + let __v_12: G = G::from_u64(6); + let __v_13: G = G::from_u64(100); + let __v_14: G = G::from_u64(232); + let __v_15: G = G::from_u64(167); + let __v_16: G = G::from_u64(240); + let __v_17: G = G::from_u64(212); + let __v_18: G = G::from_u64(176); + let __v_19: G = G::from_u64(236); + let __v_20: G = G::from_u64(31); + let __v_21: G = G::from_u64(197); + let __v_22: G = G::from_u64(175); + let __v_23: G = G::from_u64(170); + let __v_24: G = G::from_u64(230); + let __v_25: G = G::from_u64(96); + let __v_26: G = G::from_u64(24); + let __v_27: G = G::from_u64(233); + let __v_28: G = G::from_u64(161); + let __v_29: G = G::from_u64(147); + let __v_30: G = G::from_u64(109); + let __v_31: G = G::from_u64(172); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_198] = [__v_32]; record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18773,41 +19352,42 @@ fn aiur_fn_199( unconstrained: bool, ) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(53); - let __v_1: G = G::from_u64(212); - let __v_2: G = G::from_u64(243); - let __v_3: G = G::from_u64(130); - let __v_4: G = G::from_u64(226); - let __v_5: G = G::from_u64(78); - let __v_6: G = G::from_u64(0); - let __v_7: G = G::from_u64(156); - let __v_8: G = G::from_u64(192); - let __v_9: G = G::from_u64(233); - let __v_10: G = G::from_u64(69); - let __v_11: G = G::from_u64(121); - let __v_12: G = G::from_u64(85); - let __v_13: G = G::from_u64(211); - let __v_14: G = G::from_u64(239); - let __v_15: G = G::from_u64(30); - let __v_16: G = G::from_u64(111); - let __v_17: G = G::from_u64(121); - let __v_18: G = G::from_u64(250); - let __v_19: G = G::from_u64(233); - let __v_20: G = G::from_u64(216); - let __v_21: G = G::from_u64(211); - let __v_22: G = G::from_u64(28); - let __v_23: G = G::from_u64(253); - let __v_24: G = G::from_u64(46); - let __v_25: G = G::from_u64(21); - let __v_26: G = G::from_u64(63); - let __v_27: G = G::from_u64(160); - let __v_28: G = G::from_u64(59); - let __v_29: G = G::from_u64(5); - let __v_30: G = G::from_u64(74); - let __v_31: G = G::from_u64(106); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(237); + let __v_1: G = G::from_u64(67); + let __v_2: G = G::from_u64(199); + let __v_3: G = G::from_u64(126); + let __v_4: G = G::from_u64(85); + let __v_5: G = G::from_u64(85); + let __v_6: G = G::from_u64(147); + let __v_7: G = G::from_u64(182); + let __v_8: G = G::from_u64(205); + let __v_9: G = G::from_u64(13); + let __v_10: G = G::from_u64(75); + let __v_11: G = G::from_u64(251); + let __v_12: G = G::from_u64(196); + let __v_13: G = G::from_u64(39); + let __v_14: G = G::from_u64(59); + let __v_15: G = G::from_u64(161); + let __v_16: G = G::from_u64(34); + let __v_17: G = G::from_u64(225); + let __v_18: G = G::from_u64(192); + let __v_19: G = G::from_u64(205); + let __v_20: G = G::from_u64(241); + let __v_21: G = G::from_u64(9); + let __v_22: G = G::from_u64(5); + let __v_23: G = G::from_u64(113); + let __v_24: G = G::from_u64(97); + let __v_25: G = G::from_u64(42); + let __v_26: G = G::from_u64(149); + let __v_27: G = G::from_u64(47); + let __v_28: G = G::from_u64(148); + let __v_29: G = G::from_u64(30); + let __v_30: G = G::from_u64(173); + let __v_31: G = G::from_u64(177); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_199] = [__v_32]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18822,41 +19402,42 @@ fn aiur_fn_200( unconstrained: bool, ) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(226); - let __v_1: G = G::from_u64(28); - let __v_2: G = G::from_u64(36); - let __v_3: G = G::from_u64(180); - let __v_4: G = G::from_u64(47); - let __v_5: G = G::from_u64(4); - let __v_6: G = G::from_u64(146); - let __v_7: G = G::from_u64(57); - let __v_8: G = G::from_u64(199); - let __v_9: G = G::from_u64(247); - let __v_10: G = G::from_u64(51); - let __v_11: G = G::from_u64(146); - let __v_12: G = G::from_u64(254); - let __v_13: G = G::from_u64(220); - let __v_14: G = G::from_u64(145); - let __v_15: G = G::from_u64(31); - let __v_16: G = G::from_u64(87); - let __v_17: G = G::from_u64(76); - let __v_18: G = G::from_u64(121); - let __v_19: G = G::from_u64(131); - let __v_20: G = G::from_u64(134); - let __v_21: G = G::from_u64(203); - let __v_22: G = G::from_u64(227); - let __v_23: G = G::from_u64(227); - let __v_24: G = G::from_u64(226); - let __v_25: G = G::from_u64(162); - let __v_26: G = G::from_u64(136); - let __v_27: G = G::from_u64(142); - let __v_28: G = G::from_u64(45); - let __v_29: G = G::from_u64(243); - let __v_30: G = G::from_u64(174); - let __v_31: G = G::from_u64(240); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(124); + let __v_1: G = G::from_u64(251); + let __v_2: G = G::from_u64(168); + let __v_3: G = G::from_u64(250); + let __v_4: G = G::from_u64(149); + let __v_5: G = G::from_u64(132); + let __v_6: G = G::from_u64(124); + let __v_7: G = G::from_u64(33); + let __v_8: G = G::from_u64(58); + let __v_9: G = G::from_u64(164); + let __v_10: G = G::from_u64(6); + let __v_11: G = G::from_u64(97); + let __v_12: G = G::from_u64(16); + let __v_13: G = G::from_u64(186); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(169); + let __v_16: G = G::from_u64(127); + let __v_17: G = G::from_u64(181); + let __v_18: G = G::from_u64(151); + let __v_19: G = G::from_u64(218); + let __v_20: G = G::from_u64(242); + let __v_21: G = G::from_u64(159); + let __v_22: G = G::from_u64(92); + let __v_23: G = G::from_u64(7); + let __v_24: G = G::from_u64(247); + let __v_25: G = G::from_u64(35); + let __v_26: G = G::from_u64(102); + let __v_27: G = G::from_u64(7); + let __v_28: G = G::from_u64(47); + let __v_29: G = G::from_u64(37); + let __v_30: G = G::from_u64(7); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_200] = [__v_32]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18871,41 +19452,42 @@ fn aiur_fn_201( unconstrained: bool, ) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(186); - let __v_1: G = G::from_u64(81); - let __v_2: G = G::from_u64(181); - let __v_3: G = G::from_u64(216); - let __v_4: G = G::from_u64(163); - let __v_5: G = G::from_u64(177); - let __v_6: G = G::from_u64(66); - let __v_7: G = G::from_u64(1); - let __v_8: G = G::from_u64(210); - let __v_9: G = G::from_u64(36); - let __v_10: G = G::from_u64(2); - let __v_11: G = G::from_u64(205); - let __v_12: G = G::from_u64(168); - let __v_13: G = G::from_u64(231); - let __v_14: G = G::from_u64(49); - let __v_15: G = G::from_u64(228); - let __v_16: G = G::from_u64(159); - let __v_17: G = G::from_u64(223); - let __v_18: G = G::from_u64(120); - let __v_19: G = G::from_u64(240); - let __v_20: G = G::from_u64(139); - let __v_21: G = G::from_u64(114); - let __v_22: G = G::from_u64(100); - let __v_23: G = G::from_u64(60); - let __v_24: G = G::from_u64(27); - let __v_25: G = G::from_u64(8); - let __v_26: G = G::from_u64(226); - let __v_27: G = G::from_u64(80); - let __v_28: G = G::from_u64(67); - let __v_29: G = G::from_u64(106); - let __v_30: G = G::from_u64(175); - let __v_31: G = G::from_u64(241); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(130); + let __v_1: G = G::from_u64(229); + let __v_2: G = G::from_u64(86); + let __v_3: G = G::from_u64(141); + let __v_4: G = G::from_u64(136); + let __v_5: G = G::from_u64(226); + let __v_6: G = G::from_u64(79); + let __v_7: G = G::from_u64(36); + let __v_8: G = G::from_u64(213); + let __v_9: G = G::from_u64(190); + let __v_10: G = G::from_u64(250); + let __v_11: G = G::from_u64(195); + let __v_12: G = G::from_u64(12); + let __v_13: G = G::from_u64(233); + let __v_14: G = G::from_u64(21); + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(14); + let __v_17: G = G::from_u64(146); + let __v_18: G = G::from_u64(89); + let __v_19: G = G::from_u64(111); + let __v_20: G = G::from_u64(85); + let __v_21: G = G::from_u64(168); + let __v_22: G = G::from_u64(34); + let __v_23: G = G::from_u64(226); + let __v_24: G = G::from_u64(159); + let __v_25: G = G::from_u64(72); + let __v_26: G = G::from_u64(118); + let __v_27: G = G::from_u64(234); + let __v_28: G = G::from_u64(58); + let __v_29: G = G::from_u64(87); + let __v_30: G = G::from_u64(147); + let __v_31: G = G::from_u64(148); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_201] = [__v_32]; record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18920,41 +19502,42 @@ fn aiur_fn_202( unconstrained: bool, ) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(74); - let __v_1: G = G::from_u64(192); - let __v_2: G = G::from_u64(158); - let __v_3: G = G::from_u64(216); - let __v_4: G = G::from_u64(255); - let __v_5: G = G::from_u64(97); - let __v_6: G = G::from_u64(228); - let __v_7: G = G::from_u64(79); - let __v_8: G = G::from_u64(17); - let __v_9: G = G::from_u64(89); - let __v_10: G = G::from_u64(188); - let __v_11: G = G::from_u64(111); - let __v_12: G = G::from_u64(176); - let __v_13: G = G::from_u64(15); - let __v_14: G = G::from_u64(215); - let __v_15: G = G::from_u64(231); - let __v_16: G = G::from_u64(44); - let __v_17: G = G::from_u64(21); - let __v_18: G = G::from_u64(222); - let __v_19: G = G::from_u64(239); - let __v_20: G = G::from_u64(234); - let __v_21: G = G::from_u64(86); - let __v_22: G = G::from_u64(157); - let __v_23: G = G::from_u64(117); - let __v_24: G = G::from_u64(93); - let __v_25: G = G::from_u64(139); - let __v_26: G = G::from_u64(29); - let __v_27: G = G::from_u64(5); - let __v_28: G = G::from_u64(245); - let __v_29: G = G::from_u64(209); - let __v_30: G = G::from_u64(145); - let __v_31: G = G::from_u64(247); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(122); + let __v_1: G = G::from_u64(178); + let __v_2: G = G::from_u64(213); + let __v_3: G = G::from_u64(42); + let __v_4: G = G::from_u64(197); + let __v_5: G = G::from_u64(47); + let __v_6: G = G::from_u64(209); + let __v_7: G = G::from_u64(245); + let __v_8: G = G::from_u64(24); + let __v_9: G = G::from_u64(9); + let __v_10: G = G::from_u64(183); + let __v_11: G = G::from_u64(24); + let __v_12: G = G::from_u64(229); + let __v_13: G = G::from_u64(60); + let __v_14: G = G::from_u64(208); + let __v_15: G = G::from_u64(88); + let __v_16: G = G::from_u64(172); + let __v_17: G = G::from_u64(75); + let __v_18: G = G::from_u64(80); + let __v_19: G = G::from_u64(214); + let __v_20: G = G::from_u64(81); + let __v_21: G = G::from_u64(80); + let __v_22: G = G::from_u64(231); + let __v_23: G = G::from_u64(138); + let __v_24: G = G::from_u64(230); + let __v_25: G = G::from_u64(25); + let __v_26: G = G::from_u64(19); + let __v_27: G = G::from_u64(156); + let __v_28: G = G::from_u64(207); + let __v_29: G = G::from_u64(19); + let __v_30: G = G::from_u64(200); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_202] = [__v_32]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18979,6 +19562,7 @@ fn aiur_fn_203( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_3]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18991,6 +19575,7 @@ fn aiur_fn_203( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_5]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19003,6 +19588,7 @@ fn aiur_fn_203( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_7]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19015,6 +19601,7 @@ fn aiur_fn_203( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_9]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19027,6 +19614,7 @@ fn aiur_fn_203( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_11]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19039,6 +19627,7 @@ fn aiur_fn_203( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_13]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19051,12 +19640,14 @@ fn aiur_fn_203( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_15]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_203] = [__v_15]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19088,7 +19679,7 @@ fn aiur_fn_204( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -19099,7 +19690,7 @@ fn aiur_fn_204( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -19110,9 +19701,10 @@ fn aiur_fn_204( let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_10, __v_14]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -19120,9 +19712,10 @@ fn aiur_fn_204( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_10, __v_14]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19135,9 +19728,10 @@ fn aiur_fn_204( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_6, __v_10]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19157,14 +19751,15 @@ fn aiur_fn_204( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_10, __v_14]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -19175,7 +19770,7 @@ fn aiur_fn_204( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; @@ -19185,9 +19780,10 @@ fn aiur_fn_204( let __v_20: G = G::from_u64(7); 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_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_19, __v_23]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19195,9 +19791,10 @@ fn aiur_fn_204( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_16, __v_20]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19207,9 +19804,10 @@ fn aiur_fn_204( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_16, __v_20]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19228,6 +19826,7 @@ fn aiur_fn_204( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_10, __v_11]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19242,6 +19841,7 @@ fn aiur_fn_204( let __v_13: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_12, __v_13]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19256,6 +19856,7 @@ fn aiur_fn_204( let __v_15: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_14, __v_15]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19265,11 +19866,12 @@ fn aiur_fn_204( let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_16, __v_17]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19287,17 +19889,18 @@ fn aiur_fn_204( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_20, __v_24]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -19317,15 +19920,16 @@ fn aiur_fn_204( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_33, __v_37]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19333,9 +19937,10 @@ fn aiur_fn_204( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_32, __v_36]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19345,9 +19950,10 @@ fn aiur_fn_204( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_32, __v_36]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19357,9 +19963,10 @@ fn aiur_fn_204( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_28, __v_32]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19369,9 +19976,10 @@ fn aiur_fn_204( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_28, __v_32]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19383,9 +19991,10 @@ fn aiur_fn_204( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_204] = [__v_18, __v_22]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19415,7 +20024,7 @@ fn aiur_fn_205( ) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -19425,14 +20034,15 @@ fn aiur_fn_205( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_205] = [__v_4, __v_8]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -19450,21 +20060,22 @@ fn aiur_fn_205( let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_16: G = G::from_u64(2); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_205] = [__v_23, __v_26]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19472,9 +20083,10 @@ fn aiur_fn_205( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_205] = [__v_10, __v_14]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19484,9 +20096,10 @@ fn aiur_fn_205( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_205] = [__v_10, __v_14]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19506,7 +20119,7 @@ fn aiur_fn_206( ) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -19516,14 +20129,15 @@ fn aiur_fn_206( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_206] = [__v_4, __v_8]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -19546,11 +20160,12 @@ fn aiur_fn_206( let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_206] = [__v_13, __v_20]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19558,9 +20173,10 @@ fn aiur_fn_206( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_206] = [__v_13, __v_17]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19570,9 +20186,10 @@ fn aiur_fn_206( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_206] = [__v_10, __v_14]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19582,9 +20199,10 @@ fn aiur_fn_206( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_206] = [__v_10, __v_14]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19612,6 +20230,7 @@ fn aiur_fn_207( 1u64 => { let __ret: [G; OUT_207] = []; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -19621,6 +20240,7 @@ fn aiur_fn_207( let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_207] = []; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19646,6 +20266,7 @@ fn aiur_fn_208( let __v_2: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_2]; record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19670,6 +20291,7 @@ fn aiur_fn_209( 1u64 => { let __ret: [G; OUT_209] = [__v_1]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -19680,6 +20302,7 @@ fn aiur_fn_209( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_7]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19712,6 +20335,7 @@ fn aiur_fn_210( let __v_6: G = (__v_0 - __v_5); let __ret: [G; OUT_210] = [__v_6]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19744,6 +20368,7 @@ fn aiur_fn_211( 1u64 => { let __ret: [G; OUT_211] = [__v_0, __v_1]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19770,6 +20395,7 @@ fn aiur_fn_211( let __v_16: G = (__v_14 + __v_15); let __ret: [G; OUT_211] = [__v_16, __v_10]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19812,6 +20438,7 @@ fn aiur_fn_211( 0u64 => { let __ret: [G; OUT_211] = [__v_25, __v_15]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19871,6 +20498,7 @@ fn aiur_fn_211( 0u64 => { let __ret: [G; OUT_211] = [__v_32, __v_18]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19919,59 +20547,60 @@ fn aiur_fn_212( let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_9: G = G::from_u64(2); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_13: G = G::from_u64(2); let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_17: G = G::from_u64(2); let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_24: G = G::from_u64(2); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_31: G = G::from_u64(2); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_38: G = G::from_u64(3); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_212] = [__v_47]; record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19998,6 +20627,7 @@ fn aiur_fn_213( 1u64 => { let __ret: [G; OUT_213] = [__v_1]; record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -20009,20 +20639,21 @@ fn aiur_fn_213( let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_213] = [__v_23]; record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20077,8 +20708,8 @@ fn aiur_fn_214( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -20088,22 +20719,24 @@ fn aiur_fn_214( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_33]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_34]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20111,6 +20744,7 @@ fn aiur_fn_214( _ => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20118,6 +20752,7 @@ fn aiur_fn_214( _ => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20125,6 +20760,7 @@ fn aiur_fn_214( _ => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20158,11 +20794,13 @@ fn aiur_fn_215( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_7]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_215] = [__v_0]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20170,6 +20808,7 @@ fn aiur_fn_215( _ => { let __ret: [G; OUT_215] = [__v_0]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20205,6 +20844,7 @@ fn aiur_fn_216( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_216] = [__v_2, __v_5, __v_8, __v_11]; record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -20252,10 +20892,11 @@ fn aiur_fn_217( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_217] = [__v_30]; record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -20272,7 +20913,7 @@ fn aiur_fn_218( 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_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -20290,25 +20931,27 @@ fn aiur_fn_218( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_218] = [__v_12, __v_15]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_218] = [__v_12, __v_15]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20323,18 +20966,19 @@ fn aiur_fn_218( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_218] = [__v_13, __v_16]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_720] = { let __args: [G; IN_720] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; @@ -20344,14 +20988,15 @@ fn aiur_fn_218( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_218] = [__v_18, __v_21]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; @@ -20361,6 +21006,7 @@ fn aiur_fn_218( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_218] = [__v_22, __v_21]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -20369,6 +21015,7 @@ fn aiur_fn_218( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_22, __v_23]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20385,9 +21032,10 @@ fn aiur_fn_218( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_218] = [__v_14, __v_17]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20400,9 +21048,10 @@ fn aiur_fn_218( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_218] = [__v_9, __v_12]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20429,16 +21078,18 @@ fn aiur_fn_219( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_219] = [__v_4, __v_3]; record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_219] = [__v_5, __v_6]; record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20480,6 +21131,7 @@ fn aiur_fn_220( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_11, __v_12]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20497,6 +21149,7 @@ fn aiur_fn_220( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_220] = [__v_15, __v_16]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20504,6 +21157,7 @@ fn aiur_fn_220( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_15, __v_16]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20513,6 +21167,7 @@ fn aiur_fn_220( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_15, __v_16]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20524,6 +21179,7 @@ fn aiur_fn_220( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_9, __v_10]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20533,6 +21189,7 @@ fn aiur_fn_220( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_5, __v_6]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20587,6 +21244,7 @@ fn aiur_fn_221( let __v_27: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_26, __v_27]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20603,6 +21261,7 @@ fn aiur_fn_221( let __v_34: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_34, __v_31]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20614,6 +21273,7 @@ fn aiur_fn_221( let __v_37: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_36, __v_37]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20624,6 +21284,7 @@ fn aiur_fn_221( let __v_38: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_38, __v_31]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20631,6 +21292,7 @@ fn aiur_fn_221( let __v_39: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_38, __v_39]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20646,6 +21308,7 @@ fn aiur_fn_221( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_21, __v_22]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20655,6 +21318,7 @@ fn aiur_fn_221( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_11, __v_12]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20679,6 +21343,7 @@ fn aiur_fn_222( 1u64 => { let __ret: [G; OUT_222] = [__v_0, __v_1]; record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20691,6 +21356,7 @@ fn aiur_fn_222( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_222] = [__v_8, __v_9]; record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20722,6 +21388,7 @@ fn aiur_fn_223( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_223] = [__v_2, __v_5, __v_8, __v_9]; record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -20792,9 +21459,10 @@ fn aiur_fn_224( match __v_36.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_224] = [__v_38]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20808,10 +21476,11 @@ fn aiur_fn_224( let __v_42: G = (__v_9 + __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_224] = [__v_46]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20828,11 +21497,12 @@ fn aiur_fn_224( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_224] = [__v_52]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20848,12 +21518,13 @@ fn aiur_fn_224( let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_224] = [__v_56]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20884,6 +21555,7 @@ fn aiur_fn_225( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_3]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20896,6 +21568,7 @@ fn aiur_fn_225( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_5]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20908,6 +21581,7 @@ fn aiur_fn_225( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_7]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20920,6 +21594,7 @@ fn aiur_fn_225( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_9]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20932,6 +21607,7 @@ fn aiur_fn_225( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_11]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20944,6 +21620,7 @@ fn aiur_fn_225( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_13]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20956,6 +21633,7 @@ fn aiur_fn_225( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_15]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20968,6 +21646,7 @@ fn aiur_fn_225( let __v_17: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_17]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20980,6 +21659,7 @@ fn aiur_fn_225( let __v_19: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_19]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20992,6 +21672,7 @@ fn aiur_fn_225( let __v_21: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_21]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21004,6 +21685,7 @@ fn aiur_fn_225( let __v_23: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_23]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21016,6 +21698,7 @@ fn aiur_fn_225( let __v_25: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_25]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21028,6 +21711,7 @@ fn aiur_fn_225( let __v_27: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_27]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21040,6 +21724,7 @@ fn aiur_fn_225( let __v_29: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_29]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21052,6 +21737,7 @@ fn aiur_fn_225( let __v_31: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_31]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21064,12 +21750,14 @@ fn aiur_fn_225( let __v_33: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_33]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __ret: [G; OUT_225] = [__v_33]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21129,15 +21817,17 @@ fn aiur_fn_226( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_226] = [__v_5, __v_3]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_226] = [__v_5, __v_8]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21152,18 +21842,20 @@ fn aiur_fn_226( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_226] = [__v_7, __v_10]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_226] = [__v_7, __v_10]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21174,15 +21866,17 @@ fn aiur_fn_226( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_226] = [__v_5, __v_6]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_226] = [__v_5, __v_8]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21224,15 +21918,17 @@ fn aiur_fn_227( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_10, __v_11]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_227] = [__v_10, __v_13]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21241,9 +21937,10 @@ fn aiur_fn_227( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_227] = [__v_8, __v_11]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21252,9 +21949,10 @@ fn aiur_fn_227( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_227] = [__v_6, __v_9]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21275,9 +21973,10 @@ fn aiur_fn_228( let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_228] = [__v_4]; record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -21302,16 +22001,18 @@ fn aiur_fn_229( 1u64 => { let __ret: [G; OUT_229] = [__v_0]; record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_229] = [__v_8]; record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21349,6 +22050,7 @@ fn aiur_fn_230( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_5, __v_8]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21367,6 +22069,7 @@ fn aiur_fn_230( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_7, __v_10]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21385,6 +22088,7 @@ fn aiur_fn_230( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_9, __v_12]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21403,6 +22107,7 @@ fn aiur_fn_230( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_11, __v_14]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21421,6 +22126,7 @@ fn aiur_fn_230( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_13, __v_16]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21439,6 +22145,7 @@ fn aiur_fn_230( let __v_18: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_15, __v_18]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21457,6 +22164,7 @@ fn aiur_fn_230( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_17, __v_20]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21475,6 +22183,7 @@ fn aiur_fn_230( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_19, __v_22]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21493,6 +22202,7 @@ fn aiur_fn_230( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_21, __v_24]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21511,6 +22221,7 @@ fn aiur_fn_230( let __v_26: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_23, __v_26]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21529,6 +22240,7 @@ fn aiur_fn_230( let __v_28: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_25, __v_28]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21547,6 +22259,7 @@ fn aiur_fn_230( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_27, __v_30]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21557,12 +22270,13 @@ fn aiur_fn_230( match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_29, __v_31]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21579,6 +22293,7 @@ fn aiur_fn_230( let __v_33: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_31, __v_33]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21586,9 +22301,10 @@ fn aiur_fn_230( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_230] = [__v_31, __v_35]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21649,23 +22365,24 @@ fn aiur_fn_231( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_231] = [__v_8, __v_0, __v_11]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_720] = { let __args: [G; IN_720] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -21679,15 +22396,17 @@ fn aiur_fn_231( let __v_19: G = G::from_u64(1); let __ret: [G; OUT_231] = [__v_19, __v_12, __v_17]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_231] = [__v_19, __v_0, __v_22]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21696,9 +22415,10 @@ fn aiur_fn_231( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_231] = [__v_19, __v_0, __v_22]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21707,9 +22427,10 @@ fn aiur_fn_231( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_231] = [__v_11, __v_0, __v_14]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21720,9 +22441,10 @@ fn aiur_fn_231( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_231] = [__v_6, __v_0, __v_9]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21752,8 +22474,8 @@ fn aiur_fn_232( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; @@ -21763,18 +22485,19 @@ fn aiur_fn_232( let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_232] = [__v_27]; record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21783,24 +22506,25 @@ fn aiur_fn_232( let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_32: G = G::from_u64(7); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_36: G = G::from_u64(3); let __v_37: G = G::from_u64(3); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_232] = [__v_44]; record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21827,6 +22551,7 @@ fn aiur_fn_233( 7u64 => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21854,6 +22579,7 @@ fn aiur_fn_233( 1u64 => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21861,6 +22587,7 @@ fn aiur_fn_233( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_233] = [__v_16]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21868,6 +22595,7 @@ fn aiur_fn_233( _ => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21875,6 +22603,7 @@ fn aiur_fn_233( _ => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21905,6 +22634,7 @@ fn aiur_fn_234( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_4, __v_5]; record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21913,22 +22643,23 @@ fn aiur_fn_234( let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_18: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_18, __v_19]; record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21979,17 +22710,18 @@ fn aiur_fn_235( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_17]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_720] = { let __args: [G; IN_720] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -22001,12 +22733,14 @@ fn aiur_fn_235( let __v_26: G = G::from_bool((__v_23 == G::ZERO)); let __ret: [G; OUT_235] = [__v_26]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_26]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22015,6 +22749,7 @@ fn aiur_fn_235( let __v_20: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_20]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22025,6 +22760,7 @@ fn aiur_fn_235( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_15]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22033,6 +22769,7 @@ fn aiur_fn_235( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_9]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22041,6 +22778,7 @@ fn aiur_fn_235( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_5]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22070,13 +22808,14 @@ fn aiur_fn_236( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_236] = [__v_7, __v_11]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -22087,16 +22826,17 @@ fn aiur_fn_236( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_236] = [__v_10, __v_14]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_720] = { let __args: [G; IN_720] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -22106,17 +22846,18 @@ fn aiur_fn_236( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_236] = [__v_15, __v_19]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __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_729] = { let __args: [G; IN_729] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -22132,6 +22873,7 @@ fn aiur_fn_236( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_236] = [__v_21, __v_24]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22140,6 +22882,7 @@ fn aiur_fn_236( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_236] = [__v_21, __v_22]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22168,7 +22911,7 @@ fn aiur_fn_237( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -22188,14 +22931,15 @@ fn aiur_fn_237( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_237] = [__v_10, __v_14]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -22203,7 +22947,7 @@ fn aiur_fn_237( match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; @@ -22214,6 +22958,7 @@ fn aiur_fn_237( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_237] = [__v_16, __v_19]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22221,9 +22966,10 @@ fn aiur_fn_237( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_237] = [__v_14, __v_18]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22241,14 +22987,15 @@ fn aiur_fn_237( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_237] = [__v_10, __v_14]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -22256,7 +23003,7 @@ fn aiur_fn_237( match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; @@ -22269,6 +23016,7 @@ fn aiur_fn_237( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_237] = [__v_16, __v_20]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22276,9 +23024,10 @@ fn aiur_fn_237( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_237] = [__v_14, __v_18]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22291,6 +23040,7 @@ fn aiur_fn_237( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_237] = [__v_8, __v_9]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22320,17 +23070,18 @@ fn aiur_fn_238( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_238] = [__v_5, __v_9]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -22348,13 +23099,14 @@ fn aiur_fn_238( match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_238] = [__v_17, __v_18]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22362,9 +23114,10 @@ fn aiur_fn_238( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_238] = [__v_15, __v_19]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22374,9 +23127,10 @@ fn aiur_fn_238( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_238] = [__v_13, __v_17]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22392,6 +23146,7 @@ fn aiur_fn_238( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_238] = [__v_13, __v_14]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22399,9 +23154,10 @@ fn aiur_fn_238( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_238] = [__v_13, __v_17]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22460,14 +23216,15 @@ fn aiur_fn_239( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_239] = [__v_22, __v_26]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -22479,6 +23236,7 @@ fn aiur_fn_239( let __v_26: G = G::from_u64(2); let __ret: [G; OUT_239] = [__v_26, __v_25]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22486,9 +23244,10 @@ fn aiur_fn_239( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_239] = [__v_26, __v_30]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22499,6 +23258,7 @@ fn aiur_fn_239( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_239] = [__v_24, __v_25]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22524,21 +23284,22 @@ fn aiur_fn_240( let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_240] = [__v_17]; record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -22567,6 +23328,7 @@ fn aiur_fn_241( 8u64 => { let __ret: [G; OUT_241] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22578,6 +23340,7 @@ fn aiur_fn_241( 1u64 => { let __ret: [G; OUT_241] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -22595,6 +23358,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -22610,6 +23374,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -22625,6 +23390,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -22640,6 +23406,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -22655,6 +23422,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -22670,6 +23438,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -22685,6 +23454,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22700,6 +23470,7 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22729,6 +23500,7 @@ fn aiur_fn_242( 0u64 => { let __ret: [G; OUT_242] = [__v_0]; record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22740,9 +23512,10 @@ fn aiur_fn_242( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_242] = [__v_7]; record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -22752,6 +23525,7 @@ fn aiur_fn_242( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_242] = [__v_7]; record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22803,7 +23577,7 @@ fn aiur_fn_243( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_0 [__v_25]; }, _ => { @@ -22833,19 +23607,21 @@ fn aiur_fn_243( 1u64 => { let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); - let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_243] = [__v_37]; record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_243] = [__v_39]; record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22855,9 +23631,10 @@ fn aiur_fn_243( }, _ => { let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_243] = [__v_35]; record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22889,9 +23666,10 @@ fn aiur_fn_244( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_244] = [__v_12]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -22899,9 +23677,10 @@ fn aiur_fn_244( let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -22910,9 +23689,10 @@ fn aiur_fn_244( let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -22921,9 +23701,10 @@ fn aiur_fn_244( let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -22931,9 +23712,10 @@ fn aiur_fn_244( let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22970,24 +23752,26 @@ fn aiur_fn_245( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_245] = [__v_14]; record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_245] = [__v_17]; record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23035,15 +23819,16 @@ fn aiur_fn_246( 0u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -23051,58 +23836,62 @@ fn aiur_fn_246( let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_26]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; @@ -23110,15 +23899,16 @@ fn aiur_fn_246( let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_29]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; @@ -23127,9 +23917,10 @@ fn aiur_fn_246( let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_30]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -23139,9 +23930,10 @@ fn aiur_fn_246( let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -23151,9 +23943,10 @@ fn aiur_fn_246( let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -23163,9 +23956,10 @@ fn aiur_fn_246( let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -23176,15 +23970,16 @@ fn aiur_fn_246( let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -23196,6 +23991,7 @@ fn aiur_fn_246( let __v_28: G = __r_arr[0]; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23251,6 +24047,7 @@ fn aiur_fn_247( let __v_21: G = G::from_u64(0); let __ret: [G; OUT_247] = [__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[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -23270,6 +24067,7 @@ fn aiur_fn_247( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_247] = [__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[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -23277,6 +24075,7 @@ fn aiur_fn_247( let __v_21: G = G::from_u64(0); let __ret: [G; OUT_247] = [__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[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23322,6 +24121,7 @@ fn aiur_fn_248( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_248] = [__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[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23362,6 +24162,7 @@ fn aiur_fn_249( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_249] = [__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[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23421,6 +24222,7 @@ fn aiur_fn_250( let __v_37: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_37]; record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -23430,6 +24232,7 @@ fn aiur_fn_250( let __v_39: G = (__v_37 + __v_38); let __ret: [G; OUT_250] = [__v_39]; record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23494,6 +24297,7 @@ fn aiur_fn_251( 0u64 => { let __ret: [G; OUT_251] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __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[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23536,6 +24340,7 @@ fn aiur_fn_251( let __v_73: G = __r_arr[33]; let __ret: [G; OUT_251] = [__v_40, __v_41, __v_42, __v_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[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23606,6 +24411,7 @@ fn aiur_fn_252( let __v_39: G = G::from_u64(0); let __ret: [G; OUT_252] = [__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[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23678,6 +24484,7 @@ fn aiur_fn_253( let __v_46: G = G::from_u64(0); let __ret: [G; OUT_253] = [__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[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23716,9 +24523,10 @@ fn aiur_fn_254( 1u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_254] = [__v_19]; record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -23733,9 +24541,10 @@ fn aiur_fn_254( let __v_21: G = (__v_5 + __v_20); let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_254] = [__v_23]; record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23827,6 +24636,7 @@ fn aiur_fn_255( let __v_58: G = __r_arr[0]; let __ret: [G; OUT_255] = [__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[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23952,6 +24762,7 @@ fn aiur_fn_256( } let __ret: [G; OUT_256] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_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[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -24015,6 +24826,7 @@ fn aiur_fn_257( 0u64 => { let __ret: [G; OUT_257] = [__v_39]; record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24078,6 +24890,7 @@ fn aiur_fn_258( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_258] = [__v_37]; record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -24099,6 +24912,7 @@ fn aiur_fn_259( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -24107,12 +24921,14 @@ fn aiur_fn_259( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24123,12 +24939,14 @@ fn aiur_fn_259( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24172,9 +24990,10 @@ fn aiur_fn_260( 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_260] = [__v_17]; record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24182,6 +25001,7 @@ fn aiur_fn_260( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_15]; record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24264,15 +25084,15 @@ fn aiur_fn_261( 0u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_0 [__v_53]; }, _ => { let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_0 [__v_55]; }, } @@ -24293,15 +25113,16 @@ fn aiur_fn_261( let __v_60: G = __r_arr[9]; let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; - let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_261] = [__v_63]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; @@ -24315,15 +25136,16 @@ fn aiur_fn_261( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_261] = [__v_64]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; @@ -24337,9 +25159,10 @@ fn aiur_fn_261( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_261] = [__v_64]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -24349,6 +25172,7 @@ fn aiur_fn_261( let __v_49: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_49]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24362,6 +25186,7 @@ fn aiur_fn_261( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_50]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24377,6 +25202,7 @@ fn aiur_fn_261( let __v_51: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_51]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24390,6 +25216,7 @@ fn aiur_fn_261( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_50]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24398,8 +25225,8 @@ fn aiur_fn_261( let __v_49: G = G::from_u64(0); let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); - let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; @@ -24414,9 +25241,10 @@ fn aiur_fn_261( let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; - let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_261] = [__v_67]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24501,7 +25329,7 @@ fn aiur_fn_262( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -24566,9 +25394,10 @@ fn aiur_fn_262( let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; - let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_262] = [__v_117]; record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24713,9 +25542,10 @@ fn aiur_fn_263( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_263] = [__v_108]; record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24898,9 +25728,10 @@ fn aiur_fn_264( let __v_140: G = __r_arr[9]; let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; - let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_264] = [__v_143]; record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25047,9 +25878,10 @@ fn aiur_fn_265( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_265] = [__v_108]; record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25132,6 +25964,7 @@ fn aiur_fn_266( 0u64 => { let __ret: [G; OUT_266] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25185,6 +26018,7 @@ fn aiur_fn_266( let __v_95: G = __r_arr[44]; let __ret: [G; OUT_266] = [__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[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25227,6 +26061,7 @@ fn aiur_fn_267( } 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].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -25367,22 +26202,23 @@ fn aiur_fn_268( let __v_100: G = __mc_out___mc_0[44]; let __v_101: G = G::from_u64(1); let __v_102: G = G::from_u64(1); - let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_107: G = G::from_u64(1); let __v_108: G = G::from_u64(1); - let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_110: G = G::from_u64(1); let __v_111: G = G::from_u64(1); - let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_114]; record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -25404,6 +26240,7 @@ fn aiur_fn_269( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_269] = [__v_3]; record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -25474,9 +26311,10 @@ fn aiur_fn_270( 1u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_270] = [__v_53]; record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25487,9 +26325,10 @@ fn aiur_fn_270( let __v_54: G = (__v_3 + __v_53); let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_270] = [__v_56]; record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25519,18 +26358,21 @@ fn aiur_fn_271( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -25545,12 +26387,14 @@ fn aiur_fn_271( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_271] = [__v_6]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_271] = [__v_6]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25559,6 +26403,7 @@ fn aiur_fn_271( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_271] = [__v_6]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25568,6 +26413,7 @@ fn aiur_fn_271( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25604,12 +26450,14 @@ fn aiur_fn_272( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25625,12 +26473,14 @@ fn aiur_fn_272( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25649,12 +26499,14 @@ fn aiur_fn_272( let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_272] = [__v_10]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25673,12 +26525,14 @@ fn aiur_fn_272( let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_272] = [__v_10]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25694,12 +26548,14 @@ fn aiur_fn_272( let __v_9: G = G::from_bool((__v_8 == G::ZERO)); let __ret: [G; OUT_272] = [__v_9]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25738,12 +26594,14 @@ fn aiur_fn_273( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_273] = [__v_8]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_273] = [__v_8]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25761,6 +26619,7 @@ fn aiur_fn_273( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_273] = [__v_8]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25770,6 +26629,7 @@ fn aiur_fn_273( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_273] = [__v_9]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25779,6 +26639,7 @@ fn aiur_fn_273( let __v_10: G = G::from_u64(2); let __ret: [G; OUT_273] = [__v_10]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25786,6 +26647,7 @@ fn aiur_fn_273( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_273] = [__v_10]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25831,6 +26693,7 @@ fn aiur_fn_274( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_274] = [__v_5]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25843,6 +26706,7 @@ fn aiur_fn_274( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_8]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25852,6 +26716,7 @@ fn aiur_fn_274( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25862,6 +26727,7 @@ fn aiur_fn_274( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_10]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25869,6 +26735,7 @@ fn aiur_fn_274( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_10]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25920,12 +26787,14 @@ fn aiur_fn_275( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25943,6 +26812,7 @@ fn aiur_fn_275( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25950,6 +26820,7 @@ fn aiur_fn_275( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25986,10 +26857,11 @@ fn aiur_fn_276( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_276] = [__v_5, __v_10]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -25998,9 +26870,10 @@ fn aiur_fn_276( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_276] = [__v_6, __v_8]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26010,6 +26883,7 @@ fn aiur_fn_276( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_276] = [__v_7, __v_1]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -26017,9 +26891,10 @@ fn aiur_fn_276( let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_276] = [__v_7, __v_10]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26059,13 +26934,14 @@ fn aiur_fn_277( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_277] = [__v_11]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26078,10 +26954,11 @@ fn aiur_fn_277( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_277] = [__v_11]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26091,9 +26968,10 @@ fn aiur_fn_277( let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_277] = [__v_12]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26101,15 +26979,17 @@ fn aiur_fn_277( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_277] = [__v_13]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_277] = [__v_0]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26163,12 +27043,14 @@ fn aiur_fn_278( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_278] = [__v_8]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_8]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26186,6 +27068,7 @@ fn aiur_fn_278( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_8]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26209,12 +27092,14 @@ fn aiur_fn_278( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_278] = [__v_14]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_14]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26223,6 +27108,7 @@ fn aiur_fn_278( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_13]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26263,6 +27149,7 @@ fn aiur_fn_279( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_279] = [__v_4]; record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26278,11 +27165,13 @@ fn aiur_fn_279( 1u64 => { let __ret: [G; OUT_279] = [__v_5]; record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_279] = [__v_6]; record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26319,6 +27208,7 @@ fn aiur_fn_280( 1u64 => { let __ret: [G; OUT_280] = [__v_0]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26330,6 +27220,7 @@ fn aiur_fn_280( 1u64 => { let __ret: [G; OUT_280] = [__v_0]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26349,9 +27240,10 @@ fn aiur_fn_280( let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_280] = [__v_15]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26362,6 +27254,7 @@ fn aiur_fn_280( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_280] = [__v_14]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26371,9 +27264,10 @@ fn aiur_fn_280( let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_280] = [__v_17]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26381,6 +27275,7 @@ fn aiur_fn_280( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_280] = [__v_15]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26431,6 +27326,7 @@ fn aiur_fn_281( 0u64 => { let __ret: [G; OUT_281] = [__v_0]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -26444,11 +27340,13 @@ fn aiur_fn_281( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_281] = [__v_6]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_281] = [__v_0]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26461,6 +27359,7 @@ fn aiur_fn_281( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_281] = [__v_3]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26489,14 +27388,15 @@ fn aiur_fn_282( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_282] = [__v_14]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26514,15 +27414,17 @@ fn aiur_fn_282( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_282] = [__v_13]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_282] = [__v_0]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26534,20 +27436,22 @@ fn aiur_fn_282( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_282] = [__v_15]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_282] = [__v_12]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26584,18 +27488,19 @@ fn aiur_fn_283( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_283] = [__v_19]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26612,34 +27517,37 @@ fn aiur_fn_283( let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_283] = [__v_14]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_283] = [__v_20]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_283] = [__v_13]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26677,6 +27585,7 @@ fn aiur_fn_284( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_7]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -26686,6 +27595,7 @@ fn aiur_fn_284( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_9]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -26695,6 +27605,7 @@ fn aiur_fn_284( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_8]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -26702,6 +27613,7 @@ fn aiur_fn_284( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_7]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -26716,6 +27628,7 @@ fn aiur_fn_284( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_10]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26723,6 +27636,7 @@ fn aiur_fn_284( 0u64 => { let __ret: [G; OUT_284] = [__v_3]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26730,6 +27644,7 @@ fn aiur_fn_284( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_9]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26771,6 +27686,7 @@ fn aiur_fn_285( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_8]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -26782,6 +27698,7 @@ fn aiur_fn_285( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_11]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -26791,6 +27708,7 @@ fn aiur_fn_285( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_9]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -26800,6 +27718,7 @@ fn aiur_fn_285( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_9]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -26816,6 +27735,7 @@ fn aiur_fn_285( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_12]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26835,6 +27755,7 @@ fn aiur_fn_285( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_11]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26869,6 +27790,7 @@ fn aiur_fn_286( 1u64 => { let __ret: [G; OUT_286] = [__v_0]; record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26877,9 +27799,10 @@ fn aiur_fn_286( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_286] = [__v_8]; record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26909,6 +27832,7 @@ fn aiur_fn_287( 1u64 => { let __ret: [G; OUT_287] = [__v_0]; record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26932,6 +27856,7 @@ fn aiur_fn_287( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_287] = [__v_12]; record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27024,11 +27949,12 @@ fn aiur_fn_287( } }; let __v_14: G = __mc_out___mc_3[0]; - let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_287] = [__v_16]; record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27044,8 +27970,8 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 1; -const IN_288: usize = 1; +const INPUT_SIZE_288: usize = 2; +const IN_288: usize = 2; const OUT_288: usize = 1; fn aiur_fn_288( inp: [G; IN_288], @@ -27053,174 +27979,109 @@ fn aiur_fn_288( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_288], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_1: G = __loaded[0]; - let __v_2: G = __loaded[1]; - let __v_3: G = __loaded[2]; - match __v_1.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_288] = [__v_0]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_4: G = __loaded[0]; - let __v_5: G = __loaded[1]; - let __v_6: G = __loaded[2]; - match __v_4.as_canonical_u64() { - _ => { - match __v_5.as_canonical_u64() { - 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __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_288] = { let __args: [G; IN_288] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_10]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __ret: [G; OUT_288] = [__v_0]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); - }, - } - }, - _ => { - let __ret: [G; OUT_288] = [__v_0]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_289: usize = 2; -const IN_289: usize = 2; -const OUT_289: usize = 1; -fn aiur_fn_289( - inp: [G; IN_289], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_4: G = __loaded[0]; - let __v_5: G = __loaded[1]; - let __v_6: G = __loaded[2]; - match __v_4.as_canonical_u64() { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_7: G = __loaded[0]; - let __v_8: G = __loaded[1]; - let __v_9: G = __loaded[2]; - match __v_7.as_canonical_u64() { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { 1u64 => { - let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_289] = [__v_10]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_288] = [__v_8]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_289] = [__v_10]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_288] = [__v_8]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_7: G = __loaded[0]; - let __v_8: G = __loaded[1]; - let __v_9: G = __loaded[2]; - match __v_7.as_canonical_u64() { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { 1u64 => { - let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_289] = [__v_10]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_288] = [__v_8]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_13: G = __loaded[0]; - let __v_14: G = __loaded[1]; - let __v_15: G = __loaded[2]; - match __v_13.as_canonical_u64() { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; - let __v_16: G = __r_arr[0]; - match __v_16.as_canonical_u64() { + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { 0u64 => { - let __v_17: G = (__v_11 - __v_14); - match __v_17.as_canonical_u64() { + let __v_15: G = (__v_9 - __v_12); + match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; - let __v_18: G = __r_arr[0]; - match __v_18.as_canonical_u64() { + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_19]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_288] = [__v_17]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_289] = [__v_19]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_288] = [__v_17]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { - let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_289] = [__v_18]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_288] = [__v_16]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_289] = [__v_17]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_288] = [__v_15]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27230,26 +28091,26 @@ fn aiur_fn_289( } }, _ => { - return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -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_289: usize = 3; +const IN_289: usize = 3; +const OUT_289: usize = 1; +fn aiur_fn_289( + inp: [G; IN_289], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27261,8 +28122,9 @@ fn aiur_fn_290( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_290] = [__v_6]; - record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_289] = [__v_6]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27276,10 +28138,11 @@ fn aiur_fn_290( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_290] = [__v_10]; - record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_289] = [__v_10]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27290,7 +28153,7 @@ fn aiur_fn_290( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -27303,15 +28166,17 @@ fn aiur_fn_290( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_290] = [__v_12]; - record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_289] = [__v_12]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_290] = [__v_12]; - record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_289] = [__v_12]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27330,15 +28195,15 @@ 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_290: usize = 2; +const IN_290: usize = 2; +const OUT_290: usize = 1; +fn aiur_fn_290( + inp: [G; IN_290], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_291], 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]; @@ -27349,8 +28214,9 @@ fn aiur_fn_291( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_291] = [__v_5]; - record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_290] = [__v_5]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27365,15 +28231,17 @@ fn aiur_fn_291( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_291] = [__v_10]; - record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_290] = [__v_10]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_291] = [__v_10]; - record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_290] = [__v_10]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27390,15 +28258,15 @@ fn aiur_fn_291( }) } -const INPUT_SIZE_292: usize = 4; -const IN_292: usize = 4; -const OUT_292: usize = 1; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_291: usize = 4; +const IN_291: usize = 4; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: [G; IN_291], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], 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]; @@ -27411,8 +28279,9 @@ fn aiur_fn_292( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_292] = [__v_7]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_291] = [__v_7]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27426,27 +28295,30 @@ fn aiur_fn_292( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_292] = [__v_11]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_291] = [__v_11]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_292] = [__v_12]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_291] = [__v_12]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_292] = [__v_12]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_291] = [__v_12]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27465,15 +28337,15 @@ fn aiur_fn_292( }) } -const INPUT_SIZE_293: usize = 3; -const IN_293: usize = 3; -const OUT_293: usize = 1; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_292: usize = 3; +const IN_292: usize = 3; +const OUT_292: usize = 1; +fn aiur_fn_292( + inp: [G; IN_292], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], 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]; @@ -27485,8 +28357,9 @@ fn aiur_fn_293( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_6]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_6]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27502,15 +28375,17 @@ fn aiur_fn_293( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_293] = [__v_10]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_10]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_293] = [__v_10]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_10]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27519,10 +28394,11 @@ fn aiur_fn_293( } }, _ => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_293] = [__v_9]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_9]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27536,15 +28412,15 @@ fn aiur_fn_293( }) } -const INPUT_SIZE_294: usize = 2; -const IN_294: usize = 2; -const OUT_294: usize = 1; -fn aiur_fn_294( - inp: [G; IN_294], +const INPUT_SIZE_293: usize = 2; +const IN_293: usize = 2; +const OUT_293: usize = 1; +fn aiur_fn_293( + inp: [G; IN_293], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], 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]; @@ -27555,8 +28431,9 @@ fn aiur_fn_294( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_294] = [__v_5]; - record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_5]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27572,7 +28449,7 @@ fn aiur_fn_294( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -27582,25 +28459,28 @@ fn aiur_fn_294( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_9]; - record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_9]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_10]; - record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_10]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_10]; - record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_10]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27622,15 +28502,15 @@ fn aiur_fn_294( }) } -const INPUT_SIZE_295: usize = 3; -const IN_295: usize = 3; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_294: usize = 3; +const IN_294: usize = 3; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], 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]; @@ -27642,8 +28522,9 @@ fn aiur_fn_295( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_295] = [__v_6]; - record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_294] = [__v_6]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27652,20 +28533,22 @@ fn aiur_fn_295( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_9]; - record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_294] = [__v_9]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_295] = [__v_9]; - record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_294] = [__v_9]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27682,44 +28565,101 @@ fn aiur_fn_295( }) } -const INPUT_SIZE_296: usize = 1; -const IN_296: usize = 1; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], +const INPUT_SIZE_295: usize = 1; +const IN_295: usize = 1; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_296], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_19]; - record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_295] = [__v_19]; + record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } +const INPUT_SIZE_296: usize = 2; +const IN_296: usize = 2; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_296], 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_272] = { let __args: [G; IN_272] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_296] = [__v_3]; + record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_296] = [__v_6]; + record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_296] = [__v_8]; + record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + const INPUT_SIZE_297: usize = 2; const IN_297: usize = 2; const OUT_297: usize = 1; @@ -27739,32 +28679,20 @@ fn aiur_fn_297( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_297] = [__v_3]; record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_3: G = __loaded[0]; - let __v_4: G = __loaded[1]; - let __v_5: G = __loaded[2]; - match __v_3.as_canonical_u64() { - 0u64 => { - let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_6]; - record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_8]; - record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_297] = [__v_5]; + record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); @@ -27785,51 +28713,12 @@ fn aiur_fn_298( 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_272] = { let __args: [G; IN_272] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - match __v_2.as_canonical_u64() { - 1u64 => { - let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_298] = [__v_3]; - record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_5]; - record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_299: usize = 2; -const IN_299: usize = 2; -const OUT_299: usize = 1; -fn aiur_fn_299( - inp: [G; IN_299], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -27837,13 +28726,15 @@ fn aiur_fn_299( 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_299] = [__v_1]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_298] = [__v_1]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_299] = [__v_0]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_298] = [__v_0]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27852,43 +28743,46 @@ fn aiur_fn_299( } }, _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_6]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_298] = [__v_6]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_4]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_298] = [__v_4]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -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_299: usize = 2; +const IN_299: usize = 2; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: [G; IN_299], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_300] = [__v_0]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_0]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27898,8 +28792,9 @@ fn aiur_fn_300( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_300] = [__v_1]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_1]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27909,33 +28804,37 @@ fn aiur_fn_300( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_300] = [__v_0]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_0]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_300] = [__v_1]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_1]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_300] = [__v_0]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_0]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_11]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_11]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27959,15 +28858,15 @@ 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_300: usize = 2; +const IN_300: usize = 2; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], 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]; @@ -27975,8 +28874,9 @@ fn aiur_fn_301( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_3]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_3]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27993,14 +28893,16 @@ fn aiur_fn_301( match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_9]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_9]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28012,16 +28914,18 @@ fn aiur_fn_301( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_301] = [__v_9]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_9]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28033,19 +28937,21 @@ fn aiur_fn_301( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_301] = [__v_11]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_11]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_9]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28057,19 +28963,21 @@ fn aiur_fn_301( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_301] = [__v_11]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_11]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_9]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28085,22 +28993,25 @@ fn aiur_fn_301( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_10]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_10]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_10]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_10]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_9]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28114,15 +29025,15 @@ fn aiur_fn_301( }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 1; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_301: usize = 2; +const IN_301: usize = 2; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], 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]; @@ -28132,20 +29043,22 @@ fn aiur_fn_302( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_302] = [__v_6]; - record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_6]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_302] = [__v_6]; - record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_6]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28155,48 +29068,51 @@ fn aiur_fn_302( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_302] = [__v_5]; - record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_5]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_303: usize = 2; -const IN_303: usize = 2; -const OUT_303: usize = 1; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_302: usize = 2; +const IN_302: usize = 2; +const OUT_302: usize = 1; +fn aiur_fn_302( + inp: [G; IN_302], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_303], 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 __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_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_305] = { let __args: [G; IN_305] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_303] = [__v_1]; - record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_302] = [__v_1]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_303] = [__v_0]; - record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_302] = [__v_0]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28206,9 +29122,10 @@ fn aiur_fn_303( }, 0u64 => { let __v_9: G = G::from_u64(2); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_10]; - record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_302] = [__v_10]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28218,15 +29135,15 @@ fn aiur_fn_303( }) } -const INPUT_SIZE_304: usize = 1; -const IN_304: usize = 1; -const OUT_304: usize = 2; -fn aiur_fn_304( - inp: [G; IN_304], +const INPUT_SIZE_303: usize = 1; +const IN_303: usize = 1; +const OUT_303: usize = 2; +fn aiur_fn_303( + inp: [G; IN_303], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_304], ExecError> { +) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -28237,12 +29154,13 @@ fn aiur_fn_304( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_4, __v_5]; - record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_303] = [__v_4, __v_5]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -28250,15 +29168,17 @@ fn aiur_fn_304( 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_304] = [__v_6, __v_8]; - record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_303] = [__v_6, __v_8]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_6, __v_7]; - record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_303] = [__v_6, __v_7]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28266,23 +29186,24 @@ fn aiur_fn_304( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_4, __v_5]; - record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_303] = [__v_4, __v_5]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_305: usize = 2; -const IN_305: usize = 2; -const OUT_305: usize = 2; -fn aiur_fn_305( - inp: [G; IN_305], +const INPUT_SIZE_304: usize = 2; +const IN_304: usize = 2; +const OUT_304: usize = 2; +fn aiur_fn_304( + inp: [G; IN_304], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_305], 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]; @@ -28294,31 +29215,33 @@ fn aiur_fn_305( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_305] = [__v_7, __v_8]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_304] = [__v_7, __v_8]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_305] = [__v_0, __v_1]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_304] = [__v_0, __v_1]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -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_305: usize = 2; +const IN_305: usize = 2; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: [G; IN_305], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_306], 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]; @@ -28330,16 +29253,18 @@ fn aiur_fn_306( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_7]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_305] = [__v_7]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_5]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_305] = [__v_5]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28347,10 +29272,11 @@ fn aiur_fn_306( let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_6]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_305] = [__v_6]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28360,8 +29286,9 @@ fn aiur_fn_306( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_306] = [__v_1]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_305] = [__v_1]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28369,15 +29296,17 @@ fn aiur_fn_306( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_306] = [__v_0]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_305] = [__v_0]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_11]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_305] = [__v_11]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28396,15 +29325,15 @@ fn aiur_fn_306( }) } -const INPUT_SIZE_307: usize = 1; -const IN_307: usize = 1; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], +const INPUT_SIZE_306: usize = 1; +const IN_306: usize = 1; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: [G; IN_306], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -28415,49 +29344,54 @@ fn aiur_fn_307( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_6]; - record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_306] = [__v_6]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_6]; - record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_306] = [__v_6]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_7]; - record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_306] = [__v_7]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_6]; - record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_6]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_6]; - record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_6]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28467,15 +29401,15 @@ fn aiur_fn_307( }) } -const INPUT_SIZE_308: usize = 2; -const IN_308: usize = 2; -const OUT_308: usize = 1; -fn aiur_fn_308( - inp: [G; IN_308], +const INPUT_SIZE_307: usize = 2; +const IN_307: usize = 2; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_308], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28487,48 +29421,53 @@ fn aiur_fn_308( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_7]; - record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_307] = [__v_7]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_8]; - record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_307] = [__v_8]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_7]; - record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_307] = [__v_7]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_7]; - record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_307] = [__v_7]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_5]; - record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_307] = [__v_5]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28538,15 +29477,15 @@ fn aiur_fn_308( }) } -const INPUT_SIZE_309: usize = 2; -const IN_309: usize = 2; -const OUT_309: usize = 1; -fn aiur_fn_309( - inp: [G; IN_309], +const INPUT_SIZE_308: usize = 2; +const IN_308: usize = 2; +const OUT_308: usize = 1; +fn aiur_fn_308( + inp: [G; IN_308], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_309], 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]; @@ -28558,20 +29497,22 @@ fn aiur_fn_309( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_7]; - record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_308] = [__v_7]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_8]; - record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_308] = [__v_8]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28581,15 +29522,15 @@ fn aiur_fn_309( }) } -const INPUT_SIZE_310: usize = 2; -const IN_310: usize = 2; -const OUT_310: usize = 1; -fn aiur_fn_310( - inp: [G; IN_310], +const INPUT_SIZE_309: usize = 2; +const IN_309: usize = 2; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: [G; IN_309], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_310], 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]; @@ -28599,30 +29540,32 @@ fn aiur_fn_310( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_310] = [__v_0]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_309] = [__v_0]; + record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_5]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_309] = [__v_5]; + record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_311: usize = 2; -const IN_311: usize = 2; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_310: usize = 2; +const IN_310: usize = 2; +const OUT_310: usize = 1; +fn aiur_fn_310( + inp: [G; IN_310], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], 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]; @@ -28635,95 +29578,104 @@ fn aiur_fn_311( 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_8]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_8]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_9]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_9]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_9]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_9]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_10]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_10]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_10]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_10]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_10]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_10]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_10]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_10]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_8]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_8]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_8]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_310] = [__v_8]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28733,15 +29685,15 @@ 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_311: usize = 2; +const IN_311: usize = 2; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: [G; IN_311], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_312], 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]; @@ -28772,14 +29724,16 @@ fn aiur_fn_312( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_312] = [__v_22]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_22]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_22]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_22]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28799,8 +29753,9 @@ fn aiur_fn_312( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_22]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_22]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28808,16 +29763,18 @@ fn aiur_fn_312( let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_23]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_23]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_23]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_23]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28837,15 +29794,15 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 2; -const IN_313: usize = 2; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_312: usize = 2; +const IN_312: usize = 2; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_313], 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]; @@ -28862,14 +29819,16 @@ fn aiur_fn_313( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_313] = [__v_8]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_8]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_313] = [__v_8]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_8]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28882,24 +29841,27 @@ fn aiur_fn_313( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_313] = [__v_8]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_8]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_9]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_9]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_313] = [__v_9]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_9]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28916,15 +29878,15 @@ fn aiur_fn_313( }) } -const INPUT_SIZE_314: usize = 4; -const IN_314: usize = 4; -const OUT_314: usize = 1; -fn aiur_fn_314( - inp: [G; IN_314], +const INPUT_SIZE_313: usize = 4; +const IN_313: usize = 4; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: [G; IN_313], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_314], 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]; @@ -28934,16 +29896,18 @@ fn aiur_fn_314( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_4]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_4]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_4]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_4]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28951,16 +29915,18 @@ fn aiur_fn_314( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_4]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_4]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_4]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_4]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28972,15 +29938,15 @@ fn aiur_fn_314( }) } -const INPUT_SIZE_315: usize = 1; -const IN_315: usize = 1; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_314: usize = 1; +const IN_314: usize = 1; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -28992,77 +29958,86 @@ fn aiur_fn_315( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_315] = [__v_6]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_6]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_5]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_5]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_5]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_5]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_5]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_5]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_7]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_7]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_8]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_8]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_8]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_8]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_5]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_5]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_5]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_5]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29072,59 +30047,62 @@ 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_315: usize = 3; +const IN_315: usize = 3; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_8]; - record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_8]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -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_316: usize = 2; +const IN_316: usize = 2; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: [G; IN_316], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_317], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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_317] = [__v_1]; - record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_316] = [__v_1]; + record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_317] = [__v_0]; - record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_316] = [__v_0]; + record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29134,57 +30112,61 @@ fn aiur_fn_317( }) } -const INPUT_SIZE_318: usize = 1; -const IN_318: usize = 1; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_317: usize = 1; +const IN_317: usize = 1; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: [G; IN_317], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_318] = [__v_1]; - record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_317] = [__v_1]; + record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_318] = [__v_2]; - record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_317] = [__v_2]; + record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_319: usize = 2; -const IN_319: usize = 2; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], +const INPUT_SIZE_318: usize = 2; +const IN_318: usize = 2; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: [G; IN_318], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_319], 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 = { 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_319] = [__v_0]; - record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_318] = [__v_0]; + record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_319] = [__v_1]; - record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_318] = [__v_1]; + record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29194,34 +30176,35 @@ 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_319: usize = 2; +const IN_319: usize = 2; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_320], 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 __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_320] = [__v_2]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_319] = [__v_2]; + record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -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_320: usize = 3; +const IN_320: usize = 3; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: [G; IN_320], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_321], 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]; @@ -29237,14 +30220,16 @@ fn aiur_fn_321( match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_321] = [__v_8]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_8]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_321] = [__v_8]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_8]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29254,37 +30239,42 @@ fn aiur_fn_321( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_321] = [__v_7]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_321] = [__v_7]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_321] = [__v_7]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_321] = [__v_8]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_8]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_8]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_8]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29293,31 +30283,35 @@ fn aiur_fn_321( } }, 4u64 => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_7]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_7]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_7]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_7]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29327,27 +30321,28 @@ fn aiur_fn_321( }) } -const INPUT_SIZE_322: usize = 4; -const IN_322: usize = 4; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_321: usize = 4; +const IN_321: usize = 4; +const OUT_321: usize = 1; +fn aiur_fn_321( + inp: [G; IN_321], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], 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 __v_3: G = inp[3]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_322] = [__v_5]; - record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_5]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -29355,10 +30350,11 @@ fn aiur_fn_322( 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_321] = { let __args: [G; IN_321] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_9]; - record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_9]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29368,38 +30364,40 @@ fn aiur_fn_322( }) } -const INPUT_SIZE_323: usize = 5; -const IN_323: usize = 5; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_322: usize = 5; +const IN_322: usize = 5; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_6]; - record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_322] = [__v_6]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_7]; - record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_322] = [__v_7]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -29407,10 +30405,11 @@ fn aiur_fn_323( 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_321] = { let __args: [G; IN_321] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_323] = [__v_11]; - record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_322] = [__v_11]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29425,60 +30424,63 @@ 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_323: usize = 2; +const IN_323: usize = 2; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_324] = [__v_4]; - record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_323] = [__v_4]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_325: usize = 2; -const IN_325: usize = 2; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: [G; IN_324], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_325], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_325] = [__v_2]; - record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_324] = [__v_2]; + record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_325] = [__v_7]; - record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_324] = [__v_7]; + record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29488,15 +30490,15 @@ fn aiur_fn_325( }) } -const INPUT_SIZE_326: usize = 1; -const IN_326: usize = 1; -const OUT_326: usize = 1; -fn aiur_fn_326( - inp: [G; IN_326], +const INPUT_SIZE_325: usize = 1; +const IN_325: usize = 1; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: [G; IN_325], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_326], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -29506,13 +30508,14 @@ fn aiur_fn_326( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); - let __ret: [G; OUT_326] = [__v_7]; - record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_325] = [__v_7]; + record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29522,44 +30525,47 @@ 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_326: usize = 2; +const IN_326: usize = 2; +const OUT_326: usize = 1; +fn aiur_fn_326( + inp: [G; IN_326], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_327], 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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_2]; - record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_326] = [__v_2]; + record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_327] = [__v_2]; - record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_326] = [__v_2]; + record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_327] = [__v_7]; - record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_326] = [__v_7]; + record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29571,15 +30577,15 @@ 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_327: usize = 2; +const IN_327: usize = 2; +const OUT_327: usize = 1; +fn aiur_fn_327( + inp: [G; IN_327], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_328], 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]; @@ -29587,28 +30593,31 @@ fn aiur_fn_328( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_328] = [__v_4]; - record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_327] = [__v_4]; + record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_328] = [__v_0]; - record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_327] = [__v_0]; + record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_328] = [__v_5]; - record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_327] = [__v_5]; + record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29620,41 +30629,44 @@ fn aiur_fn_328( }) } -const INPUT_SIZE_329: usize = 3; -const IN_329: usize = 3; -const OUT_329: usize = 1; -fn aiur_fn_329( - inp: [G; IN_329], +const INPUT_SIZE_328: usize = 3; +const IN_328: usize = 3; +const OUT_328: usize = 1; +fn aiur_fn_328( + inp: [G; IN_328], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_329], 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 __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_329] = [__v_0]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_328] = [__v_0]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_329] = [__v_0]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_328] = [__v_0]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_329] = [__v_5]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_328] = [__v_5]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29666,15 +30678,15 @@ fn aiur_fn_329( }) } -const INPUT_SIZE_330: usize = 3; -const IN_330: usize = 3; -const OUT_330: usize = 1; -fn aiur_fn_330( - inp: [G; IN_330], +const INPUT_SIZE_329: usize = 3; +const IN_329: usize = 3; +const OUT_329: usize = 1; +fn aiur_fn_329( + inp: [G; IN_329], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_330], 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]; @@ -29686,90 +30698,99 @@ fn aiur_fn_330( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_330] = [__v_7]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_329] = [__v_7]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_9]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_9]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_11]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_329] = [__v_11]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_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_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_13]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_329] = [__v_13]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_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_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_13]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_329] = [__v_13]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_330] = [__v_7]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_329] = [__v_7]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_9]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_9]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29779,15 +30800,15 @@ fn aiur_fn_330( }) } -const INPUT_SIZE_331: usize = 3; -const IN_331: usize = 3; -const OUT_331: usize = 1; -fn aiur_fn_331( - inp: [G; IN_331], +const INPUT_SIZE_330: usize = 3; +const IN_330: usize = 3; +const OUT_330: usize = 1; +fn aiur_fn_330( + inp: [G; IN_330], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_331], 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]; @@ -29797,18 +30818,20 @@ fn aiur_fn_331( 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_331] = [__v_6]; - record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_330] = [__v_6]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_331] = [__v_7]; - record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_330] = [__v_7]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29818,15 +30841,15 @@ fn aiur_fn_331( }) } -const INPUT_SIZE_332: usize = 5; -const IN_332: usize = 5; -const OUT_332: usize = 1; -fn aiur_fn_332( - inp: [G; IN_332], +const INPUT_SIZE_331: usize = 5; +const IN_331: usize = 5; +const OUT_331: usize = 1; +fn aiur_fn_331( + inp: [G; IN_331], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_332], 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]; @@ -29834,56 +30857,60 @@ fn aiur_fn_332( 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_329] = { let __args: [G; IN_329] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_11]; - record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_331] = [__v_11]; + record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_333: usize = 3; -const IN_333: usize = 3; -const OUT_333: usize = 1; -fn aiur_fn_333( - inp: [G; IN_333], +const INPUT_SIZE_332: usize = 3; +const IN_332: usize = 3; +const OUT_332: usize = 1; +fn aiur_fn_332( + inp: [G; IN_332], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_333], ExecError> { +) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_333] = [__v_0]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_332] = [__v_0]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_333] = [__v_0]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_332] = [__v_0]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_5]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_332] = [__v_5]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29895,15 +30922,15 @@ fn aiur_fn_333( }) } -const INPUT_SIZE_334: usize = 3; -const IN_334: usize = 3; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_333: usize = 3; +const IN_333: usize = 3; +const OUT_333: usize = 1; +fn aiur_fn_333( + inp: [G; IN_333], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], 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]; @@ -29918,17 +30945,19 @@ fn aiur_fn_334( 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_334] = [__v_0]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_333] = [__v_0]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_11]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_11]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29939,89 +30968,97 @@ fn aiur_fn_334( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_9]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_9]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_9]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_9]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_11]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_11]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_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_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_13]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_13]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_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_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_13]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_13]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_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_333] = { let __args: [G; IN_333] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_13]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_13]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_9]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_9]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_9]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_333] = [__v_9]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30031,34 +31068,36 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 3; -const IN_335: usize = 3; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_334: usize = 3; +const IN_334: usize = 3; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: [G; IN_334], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_335] = [__v_0]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_0]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_335] = [__v_5]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_5]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30068,15 +31107,15 @@ fn aiur_fn_335( }) } -const INPUT_SIZE_336: usize = 3; -const IN_336: usize = 3; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_335: usize = 3; +const IN_335: usize = 3; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: [G; IN_335], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30088,90 +31127,99 @@ fn aiur_fn_336( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_7]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_335] = [__v_7]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_9]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_335] = [__v_9]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_9]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_335] = [__v_9]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_11]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_335] = [__v_11]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_13]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_335] = [__v_13]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_13]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_335] = [__v_13]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_7]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_335] = [__v_7]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_9]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_335] = [__v_9]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_9]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_335] = [__v_9]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30181,28 +31229,29 @@ fn aiur_fn_336( }) } -const INPUT_SIZE_337: usize = 3; -const IN_337: usize = 3; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_336: usize = 3; +const IN_336: usize = 3; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: [G; IN_336], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_6]; - record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_336] = [__v_6]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -30210,10 +31259,11 @@ fn aiur_fn_337( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_6]; - record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_6]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30221,9 +31271,10 @@ fn aiur_fn_337( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_9]; - record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_336] = [__v_9]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -30235,15 +31286,15 @@ fn aiur_fn_337( }) } -const INPUT_SIZE_338: usize = 5; -const IN_338: usize = 5; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_337: usize = 5; +const IN_337: usize = 5; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: [G; IN_337], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], 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]; @@ -30251,49 +31302,52 @@ fn aiur_fn_338( 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_335] = { let __args: [G; IN_335] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_335] = { let __args: [G; IN_335] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_338] = [__v_11]; - record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_337] = [__v_11]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_339: usize = 3; -const IN_339: usize = 3; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_338: usize = 3; +const IN_338: usize = 3; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_339] = [__v_0]; - record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_338] = [__v_0]; + record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_339] = [__v_5]; - record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_338] = [__v_5]; + record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30303,42 +31357,44 @@ fn aiur_fn_339( }) } -const INPUT_SIZE_340: usize = 3; -const IN_340: usize = 3; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_339: usize = 3; +const IN_339: usize = 3; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: [G; IN_339], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_8]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_339] = [__v_8]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_9]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_339] = [__v_9]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30348,15 +31404,15 @@ fn aiur_fn_340( }) } -const INPUT_SIZE_341: usize = 3; -const IN_341: usize = 3; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_340: usize = 3; +const IN_340: usize = 3; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: [G; IN_340], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], 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]; @@ -30368,90 +31424,99 @@ fn aiur_fn_341( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_7]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_340] = [__v_7]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_9]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_340] = [__v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_9]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_340] = [__v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_11]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_340] = [__v_11]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_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_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_13]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_340] = [__v_13]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_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_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_13]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_340] = [__v_13]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_7]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_340] = [__v_7]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_9]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_340] = [__v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_9]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_340] = [__v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30461,15 +31526,15 @@ fn aiur_fn_341( }) } -const INPUT_SIZE_342: usize = 5; -const IN_342: usize = 5; -const OUT_342: usize = 1; -fn aiur_fn_342( - inp: [G; IN_342], +const INPUT_SIZE_341: usize = 5; +const IN_341: usize = 5; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: [G; IN_341], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_342], 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]; @@ -30477,30 +31542,31 @@ fn aiur_fn_342( 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_339] = { let __args: [G; IN_339] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_342] = [__v_11]; - record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_341] = [__v_11]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_343: usize = 3; -const IN_343: usize = 3; -const OUT_343: usize = 3; -fn aiur_fn_343( - inp: [G; IN_343], +const INPUT_SIZE_342: usize = 3; +const IN_342: usize = 3; +const OUT_342: usize = 3; +fn aiur_fn_342( + inp: [G; IN_342], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_343], 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]; @@ -30519,18 +31585,20 @@ fn aiur_fn_343( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_343] = [__v_12, __v_13, __v_14]; - record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_342] = [__v_12, __v_13, __v_14]; + record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_343] = [__v_0, __v_2, __v_1]; - record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_342] = [__v_0, __v_2, __v_1]; + record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30539,80 +31607,84 @@ fn aiur_fn_343( } }, _ => { - let __ret: [G; OUT_343] = [__v_0, __v_2, __v_1]; - record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_342] = [__v_0, __v_2, __v_1]; + record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_344: usize = 3; -const IN_344: usize = 3; -const OUT_344: usize = 1; -fn aiur_fn_344( - inp: [G; IN_344], +const INPUT_SIZE_343: usize = 3; +const IN_343: usize = 3; +const OUT_343: usize = 1; +fn aiur_fn_343( + inp: [G; IN_343], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_344], ExecError> { +) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_10]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_343] = [__v_10]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_14]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_343] = [__v_14]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_12]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_343] = [__v_12]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_345: usize = 3; -const IN_345: usize = 3; -const OUT_345: usize = 1; -fn aiur_fn_345( - inp: [G; IN_345], +const INPUT_SIZE_344: usize = 3; +const IN_344: usize = 3; +const OUT_344: usize = 1; +fn aiur_fn_344( + inp: [G; IN_344], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_345], 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]; @@ -30627,87 +31699,94 @@ fn aiur_fn_345( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_10]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_10]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_7]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_7]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_7]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_7]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_9]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_9]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_7]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_7]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_7]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_7]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_346: usize = 5; -const IN_346: usize = 5; -const OUT_346: usize = 1; -fn aiur_fn_346( - inp: [G; IN_346], +const INPUT_SIZE_345: usize = 5; +const IN_345: usize = 5; +const OUT_345: usize = 1; +fn aiur_fn_345( + inp: [G; IN_345], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_346], 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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __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_345] = { let __args: [G; IN_345] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_11]; - record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_11]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30718,7 +31797,7 @@ fn aiur_fn_346( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -30736,32 +31815,35 @@ fn aiur_fn_346( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_30]; - record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_30]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_30]; - record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_30]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_17]; - record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_17]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -30770,15 +31852,15 @@ fn aiur_fn_346( }) } -const INPUT_SIZE_347: usize = 0; -const IN_347: usize = 0; -const OUT_347: usize = 1; -fn aiur_fn_347( - inp: [G; IN_347], +const INPUT_SIZE_346: usize = 0; +const IN_346: usize = 0; +const OUT_346: usize = 1; +fn aiur_fn_346( + inp: [G; IN_346], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_347], ExecError> { +) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(116); let __v_1: G = G::from_u64(89); @@ -30812,22 +31894,23 @@ fn aiur_fn_347( let __v_29: G = G::from_u64(86); let __v_30: G = G::from_u64(91); let __v_31: G = G::from_u64(151); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_347] = [__v_32]; - record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_346] = [__v_32]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_348: usize = 0; -const IN_348: usize = 0; -const OUT_348: usize = 1; -fn aiur_fn_348( - inp: [G; IN_348], +const INPUT_SIZE_347: usize = 0; +const IN_347: usize = 0; +const OUT_347: usize = 1; +fn aiur_fn_347( + inp: [G; IN_347], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_348], ExecError> { +) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(55); @@ -30861,22 +31944,23 @@ fn aiur_fn_348( let __v_29: G = G::from_u64(179); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(25); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_348] = [__v_32]; - record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_347] = [__v_32]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_349: usize = 0; -const IN_349: usize = 0; -const OUT_349: usize = 1; -fn aiur_fn_349( - inp: [G; IN_349], +const INPUT_SIZE_348: usize = 0; +const IN_348: usize = 0; +const OUT_348: usize = 1; +fn aiur_fn_348( + inp: [G; IN_348], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_349], ExecError> { +) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(57); let __v_1: G = G::from_u64(138); @@ -30910,22 +31994,23 @@ fn aiur_fn_349( let __v_29: G = G::from_u64(242); let __v_30: G = G::from_u64(182); let __v_31: G = G::from_u64(49); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_349] = [__v_32]; - record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_348] = [__v_32]; + record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_350: usize = 0; -const IN_350: usize = 0; -const OUT_350: usize = 1; -fn aiur_fn_350( - inp: [G; IN_350], +const INPUT_SIZE_349: usize = 0; +const IN_349: usize = 0; +const OUT_349: usize = 1; +fn aiur_fn_349( + inp: [G; IN_349], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_350], ExecError> { +) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(136); let __v_1: G = G::from_u64(38); @@ -30959,22 +32044,23 @@ fn aiur_fn_350( let __v_29: G = G::from_u64(125); let __v_30: G = G::from_u64(236); let __v_31: G = G::from_u64(246); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_350] = [__v_32]; - record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_349] = [__v_32]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_351: usize = 0; -const IN_351: usize = 0; -const OUT_351: usize = 1; -fn aiur_fn_351( - inp: [G; IN_351], +const INPUT_SIZE_350: usize = 0; +const IN_350: usize = 0; +const OUT_350: usize = 1; +fn aiur_fn_350( + inp: [G; IN_350], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_351], ExecError> { +) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(141); let __v_1: G = G::from_u64(196); @@ -31008,22 +32094,23 @@ fn aiur_fn_351( let __v_29: G = G::from_u64(139); let __v_30: G = G::from_u64(123); let __v_31: G = G::from_u64(208); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_351] = [__v_32]; - record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_350] = [__v_32]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_352: usize = 0; -const IN_352: usize = 0; -const OUT_352: usize = 1; -fn aiur_fn_352( - inp: [G; IN_352], +const INPUT_SIZE_351: usize = 0; +const IN_351: usize = 0; +const OUT_351: usize = 1; +fn aiur_fn_351( + inp: [G; IN_351], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_352], ExecError> { +) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(18); let __v_1: G = G::from_u64(73); @@ -31057,28 +32144,29 @@ fn aiur_fn_352( let __v_29: G = G::from_u64(176); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(22); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_32]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_351] = [__v_32]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_353: usize = 4; -const IN_353: usize = 4; -const OUT_353: usize = 2; -fn aiur_fn_353( - inp: [G; IN_353], +const INPUT_SIZE_352: usize = 4; +const IN_352: usize = 4; +const OUT_352: usize = 2; +fn aiur_fn_352( + inp: [G; IN_352], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_353], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -31088,9 +32176,10 @@ fn aiur_fn_353( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_6, __v_10]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_6, __v_10]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31103,7 +32192,7 @@ fn aiur_fn_353( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -31113,13 +32202,14 @@ fn aiur_fn_353( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_12, __v_16]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_12, __v_16]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -31129,26 +32219,27 @@ fn aiur_fn_353( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_15, __v_19]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_15, __v_19]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -31165,10 +32256,10 @@ fn aiur_fn_353( match __v_29.as_canonical_u64() { 4u64 => { let __v_33: G = G::from_u64(8); - let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_35: G = G::from_u64(4); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; let __v_39: G = __loaded[1]; @@ -31177,47 +32268,48 @@ fn aiur_fn_353( match __v_38.as_canonical_u64() { 4u64 => { let __v_42: G = G::from_u64(8); - let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(4); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_54: G = G::from_u64(4); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_57: G = G::from_u64(2); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_63: G = G::from_u64(3); let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_66: G = G::from_u64(3); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_69: G = G::from_u64(3); let __v_70: G = G::from_u64(0); - let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_72: G = G::from_u64(3); let __v_73: G = G::from_u64(0); - let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_77, __v_78]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_352] = [__v_77, __v_78]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31225,9 +32317,10 @@ fn aiur_fn_353( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_42, __v_46]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_42, __v_46]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31237,9 +32330,10 @@ fn aiur_fn_353( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_33, __v_37]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_33, __v_37]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31249,9 +32343,10 @@ fn aiur_fn_353( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_29, __v_33]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_29, __v_33]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31265,9 +32360,10 @@ fn aiur_fn_353( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_10, __v_14]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_10, __v_14]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31277,9 +32373,10 @@ fn aiur_fn_353( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_6, __v_10]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_352] = [__v_6, __v_10]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31288,15 +32385,15 @@ fn aiur_fn_353( }) } -const INPUT_SIZE_354: usize = 1; -const IN_354: usize = 1; -const OUT_354: usize = 1; -fn aiur_fn_354( - inp: [G; IN_354], +const INPUT_SIZE_353: usize = 1; +const IN_353: usize = 1; +const OUT_353: usize = 1; +fn aiur_fn_353( + inp: [G; IN_353], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_354], ExecError> { +) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -31308,8 +32405,9 @@ fn aiur_fn_354( 2u64 => { let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_5]; - record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_5]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31318,29 +32416,30 @@ fn aiur_fn_354( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_354] = [__v_15]; - record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_353] = [__v_15]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_354: usize = 2; +const IN_354: usize = 2; +const OUT_354: usize = 1; +fn aiur_fn_354( + inp: [G; IN_354], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_355], 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]; @@ -31352,20 +32451,22 @@ fn aiur_fn_355( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_355] = [__v_7]; - record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_354] = [__v_7]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_355] = [__v_8]; - record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_354] = [__v_8]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31375,43 +32476,44 @@ fn aiur_fn_355( }) } -const INPUT_SIZE_356: usize = 3; -const IN_356: usize = 3; -const OUT_356: usize = 2; -fn aiur_fn_356( - inp: [G; IN_356], +const INPUT_SIZE_355: usize = 3; +const IN_355: usize = 3; +const OUT_355: usize = 2; +fn aiur_fn_355( + inp: [G; IN_355], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_356], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_356] = [__v_4, __v_5]; - record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_355] = [__v_4, __v_5]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_357: usize = 2; -const IN_357: usize = 2; -const OUT_357: usize = 1; -fn aiur_fn_357( - inp: [G; IN_357], +const INPUT_SIZE_356: usize = 2; +const IN_356: usize = 2; +const OUT_356: usize = 1; +fn aiur_fn_356( + inp: [G; IN_356], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_357], 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_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -31419,8 +32521,9 @@ fn aiur_fn_357( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_357] = [__v_2]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_356] = [__v_2]; + record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -31430,26 +32533,28 @@ fn aiur_fn_357( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_357] = [__v_2]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_356] = [__v_2]; + record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_357] = [__v_17]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_356] = [__v_17]; + record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31464,15 +32569,15 @@ fn aiur_fn_357( }) } -const INPUT_SIZE_358: usize = 1; -const IN_358: usize = 1; -const OUT_358: usize = 1; -fn aiur_fn_358( - inp: [G; IN_358], +const INPUT_SIZE_357: usize = 1; +const IN_357: usize = 1; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: [G; IN_357], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_358], ExecError> { +) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; @@ -31480,8 +32585,9 @@ fn aiur_fn_358( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_358] = [__v_2]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_2]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31490,8 +32596,9 @@ fn aiur_fn_358( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(2); - let __ret: [G; OUT_358] = [__v_3]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_3]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31500,8 +32607,9 @@ fn aiur_fn_358( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(3); - let __ret: [G; OUT_358] = [__v_4]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_4]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31510,24 +32618,27 @@ fn aiur_fn_358( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(4); - let __ret: [G; OUT_358] = [__v_5]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_5]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(5); - let __ret: [G; OUT_358] = [__v_6]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_358] = [__v_6]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31542,63 +32653,68 @@ fn aiur_fn_358( }) } -const INPUT_SIZE_359: usize = 4; -const IN_359: usize = 4; -const OUT_359: usize = 2; -fn aiur_fn_359( - inp: [G; IN_359], +const INPUT_SIZE_358: usize = 4; +const IN_358: usize = 4; +const OUT_358: usize = 2; +fn aiur_fn_358( + inp: [G; IN_358], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_359], 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 __v_3: G = inp[3]; - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_359] = [__v_5, __v_6]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_5, __v_6]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_359] = [__v_6, __v_7]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_6, __v_7]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_359] = [__v_5, __v_6]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_5, __v_6]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_359] = [__v_5, __v_6]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_5, __v_6]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_359] = [__v_5, __v_6]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_5, __v_6]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31606,53 +32722,56 @@ fn aiur_fn_359( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_5, __v_9]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_358] = [__v_5, __v_9]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_360: usize = 3; -const IN_360: usize = 3; -const OUT_360: usize = 2; -fn aiur_fn_360( - inp: [G; IN_360], +const INPUT_SIZE_359: usize = 3; +const IN_359: usize = 3; +const OUT_359: usize = 2; +fn aiur_fn_359( + inp: [G; IN_359], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_360], 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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_360] = [__v_5, __v_6]; - record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_5, __v_6]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_360] = [__v_7, __v_8]; - record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_7, __v_8]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31660,9 +32779,10 @@ fn aiur_fn_360( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_7, __v_11]; - record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_359] = [__v_7, __v_11]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31671,19 +32791,19 @@ fn aiur_fn_360( }) } -const INPUT_SIZE_361: usize = 2; -const IN_361: usize = 2; -const OUT_361: usize = 2; -fn aiur_fn_361( - inp: [G; IN_361], +const INPUT_SIZE_360: usize = 2; +const IN_360: usize = 2; +const OUT_360: usize = 2; +fn aiur_fn_360( + inp: [G; IN_360], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_361], 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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -31693,34 +32813,36 @@ fn aiur_fn_361( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_361] = [__v_5, __v_9]; - record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_360] = [__v_5, __v_9]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __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_729] = { let __args: [G; IN_729] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_361] = [__v_13, __v_17]; - record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_360] = [__v_13, __v_17]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31728,9 +32850,10 @@ fn aiur_fn_361( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_361] = [__v_11, __v_15]; - record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_360] = [__v_11, __v_15]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31739,19 +32862,19 @@ fn aiur_fn_361( }) } -const INPUT_SIZE_362: usize = 2; -const IN_362: usize = 2; -const OUT_362: usize = 2; -fn aiur_fn_362( - inp: [G; IN_362], +const INPUT_SIZE_361: usize = 2; +const IN_361: usize = 2; +const OUT_361: usize = 2; +fn aiur_fn_361( + inp: [G; IN_361], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_362], 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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -31761,34 +32884,36 @@ fn aiur_fn_362( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_362] = [__v_5, __v_9]; - record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_361] = [__v_5, __v_9]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __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_729] = { let __args: [G; IN_729] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_362] = [__v_13, __v_17]; - record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_361] = [__v_13, __v_17]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31796,9 +32921,10 @@ fn aiur_fn_362( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_362] = [__v_11, __v_15]; - record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_361] = [__v_11, __v_15]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31807,19 +32933,19 @@ fn aiur_fn_362( }) } -const INPUT_SIZE_363: usize = 2; -const IN_363: usize = 2; -const OUT_363: usize = 2; -fn aiur_fn_363( - inp: [G; IN_363], +const INPUT_SIZE_362: usize = 2; +const IN_362: usize = 2; +const OUT_362: usize = 2; +fn aiur_fn_362( + inp: [G; IN_362], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_363], 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -31831,13 +32957,13 @@ fn aiur_fn_363( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -31845,10 +32971,11 @@ fn aiur_fn_363( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_14, __v_16]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_362] = [__v_14, __v_16]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31856,9 +32983,10 @@ fn aiur_fn_363( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_14, __v_18]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_362] = [__v_14, __v_18]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31868,9 +32996,10 @@ fn aiur_fn_363( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_11, __v_15]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_362] = [__v_11, __v_15]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31880,44 +33009,47 @@ fn aiur_fn_363( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9, __v_13]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_362] = [__v_9, __v_13]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_364: usize = 5; -const IN_364: usize = 5; -const OUT_364: usize = 1; -fn aiur_fn_364( - inp: [G; IN_364], +const INPUT_SIZE_363: usize = 5; +const IN_363: usize = 5; +const OUT_363: usize = 1; +fn aiur_fn_363( + inp: [G; IN_363], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_364], 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]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_7]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_7]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_364] = [__v_6]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_6]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31938,24 +33070,26 @@ fn aiur_fn_364( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_22]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_22]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_23]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_23]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31963,43 +33097,47 @@ fn aiur_fn_364( 2u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_20]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_20]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_22]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_22]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_22]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_22]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 7u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_23]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_23]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -32008,30 +33146,33 @@ fn aiur_fn_364( let __v_23: G = (__v_11 + __v_13); let __v_24: G = (__v_23 + __v_14); let __v_25: G = (__v_24 + __v_12); - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_10, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_22, __v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_22, __v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_28]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_28]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_25]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_25]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_364] = [__v_22]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_22]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32041,8 +33182,9 @@ fn aiur_fn_364( _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_23]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_23]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32050,8 +33192,9 @@ fn aiur_fn_364( _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_20]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_20]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32060,20 +33203,20 @@ fn aiur_fn_364( }) } -const INPUT_SIZE_365: usize = 2; -const IN_365: usize = 2; -const OUT_365: usize = 2; -fn aiur_fn_365( - inp: [G; IN_365], +const INPUT_SIZE_364: usize = 2; +const IN_364: usize = 2; +const OUT_364: usize = 2; +fn aiur_fn_364( + inp: [G; IN_364], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_365], 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 = G::from_u64(0); - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -32081,7 +33224,7 @@ fn aiur_fn_365( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { @@ -32090,23 +33233,25 @@ fn aiur_fn_365( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_10, __v_14]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_364] = [__v_10, __v_14]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); - let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_14, __v_15]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_14, __v_15]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32116,24 +33261,25 @@ fn aiur_fn_365( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_8, __v_12]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_364] = [__v_8, __v_12]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_366: usize = 2; -const IN_366: usize = 2; -const OUT_366: usize = 5; -fn aiur_fn_366( - inp: [G; IN_366], +const INPUT_SIZE_365: usize = 2; +const IN_365: usize = 2; +const OUT_365: usize = 5; +fn aiur_fn_365( + inp: [G; IN_365], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_366], 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]; @@ -32146,14 +33292,15 @@ fn aiur_fn_366( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __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_366] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -32171,8 +33318,9 @@ fn aiur_fn_366( 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_366] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32210,11 +33358,12 @@ fn aiur_fn_366( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __ret: [G; OUT_366] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_11, __v_12, __v_45, __v_46, __v_47]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32254,11 +33403,12 @@ fn aiur_fn_366( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_366] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_10, __v_11, __v_44, __v_45, __v_46]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32298,26 +33448,27 @@ fn aiur_fn_366( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_366] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_6, __v_7, __v_40, __v_41, __v_42]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_367: usize = 1; -const IN_367: usize = 1; -const OUT_367: usize = 1; -fn aiur_fn_367( - inp: [G; IN_367], +const INPUT_SIZE_366: usize = 1; +const IN_366: usize = 1; +const OUT_366: usize = 1; +fn aiur_fn_366( + inp: [G; IN_366], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_367], ExecError> { +) -> Result<[G; OUT_366], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -32338,11 +33489,12 @@ fn aiur_fn_367( let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_367] = [__v_12]; - record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_366] = [__v_12]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32353,49 +33505,52 @@ fn aiur_fn_367( let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_12: G = G::from_u64(2); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_367] = [__v_21]; - record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_366] = [__v_21]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_367] = [__v_0]; - record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_366] = [__v_0]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_367] = [__v_0]; - record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_366] = [__v_0]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_368: usize = 10; -const IN_368: usize = 10; -const OUT_368: usize = 1; -fn aiur_fn_368( - inp: [G; IN_368], +const INPUT_SIZE_367: usize = 10; +const IN_367: usize = 10; +const OUT_367: usize = 1; +fn aiur_fn_367( + inp: [G; IN_367], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_368], 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]; @@ -32420,35 +33575,37 @@ fn aiur_fn_368( let __v_15: G = (__v_4 + __v_5); let __v_16: G = (__v_3 + __v_15); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_18, __v_11, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_18, __v_11, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_368] = [__v_7]; - record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_367] = [__v_7]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_3 + __v_4); let __v_22: G = (__v_2 + __v_21); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_17 + __v_24); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_27, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_29]; - record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_367] = [__v_29]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32456,32 +33613,33 @@ fn aiur_fn_368( } }, _ => { - let __ret: [G; OUT_368] = [__v_7]; - record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_367] = [__v_7]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_369: usize = 5; -const IN_369: usize = 5; -const OUT_369: usize = 1; -fn aiur_fn_369( - inp: [G; IN_369], +const INPUT_SIZE_368: usize = 5; +const IN_368: usize = 5; +const OUT_368: usize = 1; +fn aiur_fn_368( + inp: [G; IN_368], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_369], 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 __v_4: G = inp[4]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -32498,8 +33656,9 @@ fn aiur_fn_369( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_369] = [__v_14]; - record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_368] = [__v_14]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32520,27 +33679,29 @@ fn aiur_fn_369( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_34]; - record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_368] = [__v_34]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_369] = [__v_27]; - record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_368] = [__v_27]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32549,57 +33710,59 @@ fn aiur_fn_369( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_369] = [__v_13]; - record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_368] = [__v_13]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_370: usize = 3; -const IN_370: usize = 3; -const OUT_370: usize = 1; -fn aiur_fn_370( - inp: [G; IN_370], +const INPUT_SIZE_369: usize = 3; +const IN_369: usize = 3; +const OUT_369: usize = 1; +fn aiur_fn_369( + inp: [G; IN_369], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_370], 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_728] = { let __args: [G; IN_728] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __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_729] = { let __args: [G; IN_729] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_370] = [__v_13]; - record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_369] = [__v_13]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_371: usize = 10; -const IN_371: usize = 10; -const OUT_371: usize = 2; -fn aiur_fn_371( - inp: [G; IN_371], +const INPUT_SIZE_370: usize = 10; +const IN_370: usize = 10; +const OUT_370: usize = 2; +fn aiur_fn_370( + inp: [G; IN_370], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_371], 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]; @@ -32614,7 +33777,7 @@ fn aiur_fn_371( 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_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_14.as_canonical_u64() { @@ -32623,9 +33786,10 @@ fn aiur_fn_371( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_371] = [__v_15, __v_19]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_370] = [__v_15, __v_19]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32635,29 +33799,30 @@ fn aiur_fn_371( match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_371] = [__v_17, __v_16]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_370] = [__v_17, __v_16]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __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_373] = { let __args: [G; IN_373] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -32669,30 +33834,31 @@ fn aiur_fn_371( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_32, __v_33]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_370] = [__v_32, __v_33]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_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_728] = { let __args: [G; IN_728] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __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_729] = { let __args: [G; IN_729] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; @@ -32701,8 +33867,9 @@ fn aiur_fn_371( let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); - let __ret: [G; OUT_371] = [__v_44, __v_43]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_370] = [__v_44, __v_43]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32711,13 +33878,14 @@ fn aiur_fn_371( } }, _ => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_27, __v_28]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_370] = [__v_27, __v_28]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32728,15 +33896,15 @@ fn aiur_fn_371( }) } -const INPUT_SIZE_372: usize = 1; -const IN_372: usize = 1; -const OUT_372: usize = 4; -fn aiur_fn_372( - inp: [G; IN_372], +const INPUT_SIZE_371: usize = 1; +const IN_371: usize = 1; +const OUT_371: usize = 4; +fn aiur_fn_371( + inp: [G; IN_371], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_372], ExecError> { +) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -32767,10 +33935,11 @@ fn aiur_fn_372( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_20, __v_13, __v_21, __v_2]; - record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_371] = [__v_20, __v_13, __v_21, __v_2]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32808,12 +33977,13 @@ fn aiur_fn_372( let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); let __v_53: G = G::from_u64(0); - let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); - let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_372] = [__v_20, __v_21, __v_54, __v_57]; - record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_371] = [__v_20, __v_21, __v_54, __v_57]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32853,27 +34023,28 @@ fn aiur_fn_372( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_372] = [__v_7, __v_8, __v_41, __v_44]; - record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_371] = [__v_7, __v_8, __v_41, __v_44]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_373: usize = 2; -const IN_373: usize = 2; -const OUT_373: usize = 3; -fn aiur_fn_373( - inp: [G; IN_373], +const INPUT_SIZE_372: usize = 2; +const IN_372: usize = 2; +const OUT_372: usize = 3; +fn aiur_fn_372( + inp: [G; IN_372], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_373], 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]; @@ -32890,9 +34061,10 @@ fn aiur_fn_373( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_7, __v_8, __v_12]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_372] = [__v_7, __v_8, __v_12]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -32902,17 +34074,19 @@ fn aiur_fn_373( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_373] = [__v_8, __v_4, __v_5]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_372] = [__v_8, __v_4, __v_5]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __ret: [G; OUT_373] = [__v_8, __v_9, __v_10]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_372] = [__v_8, __v_9, __v_10]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32926,15 +34100,15 @@ fn aiur_fn_373( }) } -const INPUT_SIZE_374: usize = 9; -const IN_374: usize = 9; -const OUT_374: usize = 2; -fn aiur_fn_374( - inp: [G; IN_374], +const INPUT_SIZE_373: usize = 9; +const IN_373: usize = 9; +const OUT_373: usize = 2; +fn aiur_fn_373( + inp: [G; IN_373], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_374], 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]; @@ -32957,9 +34131,10 @@ fn aiur_fn_374( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_14, __v_18]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_14, __v_18]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -32975,9 +34150,10 @@ fn aiur_fn_374( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_19, __v_23]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_19, __v_23]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -32986,7 +34162,7 @@ fn aiur_fn_374( 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_375] = { let __args: [G; IN_375] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -32995,9 +34171,10 @@ fn aiur_fn_374( let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_24, __v_28]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_24, __v_28]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33024,7 +34201,7 @@ fn aiur_fn_374( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -33032,17 +34209,18 @@ fn aiur_fn_374( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_40, __v_44]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_40, __v_44]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_41, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_41, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; match __v_42.as_canonical_u64() { 1u64 => { @@ -33050,32 +34228,34 @@ fn aiur_fn_374( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_43, __v_47]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_43, __v_47]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = (__v_3 + __v_4); let __v_45: G = (__v_44 + __v_5); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_43, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_47, __v_23, __v_40, __v_11, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_47, __v_23, __v_40, __v_11, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_21 + __v_50); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_53, __v_54]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_373] = [__v_53, __v_54]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33087,9 +34267,10 @@ fn aiur_fn_374( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_39, __v_43]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_39, __v_43]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33099,9 +34280,10 @@ fn aiur_fn_374( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_39, __v_43]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_39, __v_43]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33111,9 +34293,10 @@ fn aiur_fn_374( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_37, __v_41]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_373] = [__v_37, __v_41]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33134,15 +34317,15 @@ fn aiur_fn_374( }) } -const INPUT_SIZE_375: usize = 2; -const IN_375: usize = 2; -const OUT_375: usize = 2; -fn aiur_fn_375( - inp: [G; IN_375], +const INPUT_SIZE_374: usize = 2; +const IN_374: usize = 2; +const OUT_374: usize = 2; +fn aiur_fn_374( + inp: [G; IN_374], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_375], ExecError> { +) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33166,8 +34349,9 @@ fn aiur_fn_375( match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_375] = [__v_12, __v_9]; - record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_12, __v_9]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33204,9 +34388,10 @@ fn aiur_fn_375( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_375] = [__v_12, __v_45]; - record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_374] = [__v_12, __v_45]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33245,9 +34430,10 @@ fn aiur_fn_375( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_375] = [__v_6, __v_39]; - record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_374] = [__v_6, __v_39]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33262,11 +34448,12 @@ fn aiur_fn_375( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_375] = [__v_8, __v_9]; - record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_8, __v_9]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33303,9 +34490,10 @@ fn aiur_fn_375( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_375] = [__v_6, __v_39]; - record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_374] = [__v_6, __v_39]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33314,15 +34502,15 @@ fn aiur_fn_375( }) } -const INPUT_SIZE_376: usize = 5; -const IN_376: usize = 5; -const OUT_376: usize = 1; -fn aiur_fn_376( - inp: [G; IN_376], +const INPUT_SIZE_375: usize = 5; +const IN_375: usize = 5; +const OUT_375: usize = 1; +fn aiur_fn_375( + inp: [G; IN_375], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_376], ExecError> { +) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33332,37 +34520,39 @@ fn aiur_fn_376( let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_376] = [__v_0]; - record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_375] = [__v_0]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(8); - let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_13]; - record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_375] = [__v_13]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_377: usize = 1; -const IN_377: usize = 1; -const OUT_377: usize = 1; -fn aiur_fn_377( - inp: [G; IN_377], +const INPUT_SIZE_376: usize = 1; +const IN_376: usize = 1; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: [G; IN_376], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_377], ExecError> { +) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; @@ -33382,34 +34572,36 @@ fn aiur_fn_377( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_16]; - record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_376] = [__v_16]; + record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_377] = [__v_14]; - record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_376] = [__v_14]; + record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_378: usize = 2; -const IN_378: usize = 2; -const OUT_378: usize = 1; -fn aiur_fn_378( - inp: [G; IN_378], +const INPUT_SIZE_377: usize = 2; +const IN_377: usize = 2; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_378], ExecError> { +) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33468,18 +34660,20 @@ fn aiur_fn_378( 8u64 => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_50]; - record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_377] = [__v_50]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_378] = [__v_54]; - record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_377] = [__v_54]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33488,15 +34682,15 @@ fn aiur_fn_378( }) } -const INPUT_SIZE_379: usize = 6; -const IN_379: usize = 6; -const OUT_379: usize = 1; -fn aiur_fn_379( - inp: [G; IN_379], +const INPUT_SIZE_378: usize = 6; +const IN_378: usize = 6; +const OUT_378: usize = 1; +fn aiur_fn_378( + inp: [G; IN_378], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_379], ExecError> { +) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33508,8 +34702,9 @@ fn aiur_fn_379( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_379] = [__v_7]; - record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_378] = [__v_7]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33530,32 +34725,35 @@ fn aiur_fn_379( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_379] = [__v_22]; - record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_378] = [__v_22]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 + __v_22); - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_379] = [__v_24]; - record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_378] = [__v_24]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_379] = [__v_20]; - record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_378] = [__v_20]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33564,22 +34762,23 @@ fn aiur_fn_379( }) } -const INPUT_SIZE_380: usize = 2; -const IN_380: usize = 2; -const OUT_380: usize = 1; -fn aiur_fn_380( - inp: [G; IN_380], +const INPUT_SIZE_379: usize = 2; +const IN_379: usize = 2; +const OUT_379: usize = 1; +fn aiur_fn_379( + inp: [G; IN_379], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_380], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_380] = [__v_0]; - record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_379] = [__v_0]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33592,15 +34791,17 @@ fn aiur_fn_380( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_380] = [__v_8]; - record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_379] = [__v_8]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_380] = [__v_0]; - record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_379] = [__v_0]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33609,15 +34810,15 @@ fn aiur_fn_380( }) } -const INPUT_SIZE_381: usize = 2; -const IN_381: usize = 2; -const OUT_381: usize = 1; -fn aiur_fn_381( - inp: [G; IN_381], +const INPUT_SIZE_380: usize = 2; +const IN_380: usize = 2; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_381], 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]; @@ -33628,43 +34829,46 @@ fn aiur_fn_381( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_380] = [__v_7]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_380] = [__v_7]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_381] = [__v_6]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_380] = [__v_6]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_382: usize = 2; -const IN_382: usize = 2; -const OUT_382: usize = 1; -fn aiur_fn_382( - inp: [G; IN_382], +const INPUT_SIZE_381: usize = 2; +const IN_381: usize = 2; +const OUT_381: usize = 1; +fn aiur_fn_381( + inp: [G; IN_381], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_382], 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]; @@ -33675,94 +34879,104 @@ fn aiur_fn_382( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_6]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_6]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_382] = [__v_7]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_7]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_382] = [__v_7]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_7]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_382] = [__v_7]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_7]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_382] = [__v_7]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_382] = [__v_8]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_8]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_8]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_8]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33770,31 +34984,33 @@ fn aiur_fn_382( } }, 8u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_6]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_6]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_382] = [__v_6]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_381] = [__v_6]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_383: usize = 2; -const IN_383: usize = 2; -const OUT_383: usize = 1; -fn aiur_fn_383( - inp: [G; IN_383], +const INPUT_SIZE_382: usize = 2; +const IN_382: usize = 2; +const OUT_382: usize = 1; +fn aiur_fn_382( + inp: [G; IN_382], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_383], 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]; @@ -33805,8 +35021,9 @@ fn aiur_fn_383( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_383] = [__v_5]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_5]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -33815,15 +35032,17 @@ fn aiur_fn_383( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_383] = [__v_6]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_6]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_383] = [__v_6]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_6]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33835,6 +35054,70 @@ fn aiur_fn_383( }) } +const INPUT_SIZE_383: usize = 2; +const IN_383: usize = 2; +const OUT_383: usize = 1; +fn aiur_fn_383( + inp: [G; IN_383], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_383] = [__v_0]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_383] = [__v_0]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_383] = [__v_0]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_383] = [__v_0]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_383] = [__v_0]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_383] = [__v_8]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + } + }) +} + const INPUT_SIZE_384: usize = 2; const IN_384: usize = 2; const OUT_384: usize = 1; @@ -33844,6 +35127,30 @@ fn aiur_fn_384( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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 = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_384] = [__v_5]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_385: usize = 2; +const IN_385: usize = 2; +const OUT_385: usize = 1; +fn aiur_fn_385( + inp: [G; IN_385], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33854,68 +35161,51 @@ fn aiur_fn_384( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_384] = [__v_0]; - record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_385] = [__v_0]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_384] = [__v_0]; - record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_385] = [__v_0]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_384] = [__v_0]; - record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_385] = [__v_0]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_384] = [__v_0]; - record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_385] = [__v_0]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_384] = [__v_0]; - record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_385] = [__v_0]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_384] = [__v_8]; - record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_385] = [__v_8]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_385: usize = 2; -const IN_385: usize = 2; -const OUT_385: usize = 1; -fn aiur_fn_385( - inp: [G; IN_385], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_385], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = G::from_u64(1); - let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_385] = [__v_5]; - record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - const INPUT_SIZE_386: usize = 2; const IN_386: usize = 2; const OUT_386: usize = 1; @@ -33925,87 +35215,30 @@ fn aiur_fn_386( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_386], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - let __v_5: G = __loaded[3]; - match __v_2.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_386] = [__v_0]; - record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 7u64 => { - let __ret: [G; OUT_386] = [__v_0]; - record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 4u64 => { - let __ret: [G; OUT_386] = [__v_0]; - record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 5u64 => { - let __ret: [G; OUT_386] = [__v_0]; - record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __ret: [G; OUT_386] = [__v_0]; - record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_386] = [__v_8]; - record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!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], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_5]; - record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_386] = [__v_5]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_388: usize = 3; -const IN_388: usize = 3; -const OUT_388: usize = 1; -fn aiur_fn_388( - inp: [G; IN_388], +const INPUT_SIZE_387: usize = 3; +const IN_387: usize = 3; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_388], ExecError> { +) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34020,144 +35253,154 @@ fn aiur_fn_388( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_10]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_387] = [__v_10]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_7]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_387] = [__v_7]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_7]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_387] = [__v_7]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_9]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_387] = [__v_9]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_7]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_387] = [__v_7]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_7]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_387] = [__v_7]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_389: usize = 3; -const IN_389: usize = 3; -const OUT_389: usize = 1; -fn aiur_fn_389( - inp: [G; IN_389], +const INPUT_SIZE_388: usize = 3; +const IN_388: usize = 3; +const OUT_388: usize = 1; +fn aiur_fn_388( + inp: [G; IN_388], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_389], ExecError> { +) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_10]; - record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_10]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_14]; - record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_14]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_12]; - record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_12]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_390: usize = 5; -const IN_390: usize = 5; -const OUT_390: usize = 1; -fn aiur_fn_390( - inp: [G; IN_390], +const INPUT_SIZE_389: usize = 5; +const IN_389: usize = 5; +const OUT_389: usize = 1; +fn aiur_fn_389( + inp: [G; IN_389], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_390], ExecError> { +) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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_386] = { let __args: [G; IN_386] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __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_388] = { let __args: [G; IN_388] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_11]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_389] = [__v_11]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34168,7 +35411,7 @@ fn aiur_fn_390( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -34186,32 +35429,35 @@ fn aiur_fn_390( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_30]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_389] = [__v_30]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_30]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_389] = [__v_30]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_17]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_389] = [__v_17]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34220,35 +35466,37 @@ fn aiur_fn_390( }) } -const INPUT_SIZE_391: usize = 5; -const IN_391: usize = 5; -const OUT_391: usize = 1; -fn aiur_fn_391( - inp: [G; IN_391], +const INPUT_SIZE_390: usize = 5; +const IN_390: usize = 5; +const OUT_390: usize = 1; +fn aiur_fn_390( + inp: [G; IN_390], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_391], ExecError> { +) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __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_386] = { let __args: [G; IN_386] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_7]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_7]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_391] = [__v_6]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_6]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34269,66 +35517,72 @@ fn aiur_fn_391( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __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_386] = { let __args: [G; IN_386] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_22]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_22]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_22]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_22]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __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_386] = { let __args: [G; IN_386] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_22]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_22]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_22]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_22]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 7u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __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_386] = { let __args: [G; IN_386] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_23]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_23]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_23]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_23]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34336,8 +35590,9 @@ fn aiur_fn_391( _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_20]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_20]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34346,40 +35601,41 @@ fn aiur_fn_391( }) } -const INPUT_SIZE_392: usize = 2; -const IN_392: usize = 2; -const OUT_392: usize = 1; -fn aiur_fn_392( - inp: [G; IN_392], +const INPUT_SIZE_391: usize = 2; +const IN_391: usize = 2; +const OUT_391: usize = 1; +fn aiur_fn_391( + inp: [G; IN_391], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_392], 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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __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_329] = { let __args: [G; IN_329] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_392] = [__v_6]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_6]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_393: usize = 12; -const IN_393: usize = 12; -const OUT_393: usize = 1; -fn aiur_fn_393( - inp: [G; IN_393], +const INPUT_SIZE_392: usize = 12; +const IN_392: usize = 12; +const OUT_392: usize = 1; +fn aiur_fn_392( + inp: [G; IN_392], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_393], ExecError> { +) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34395,43 +35651,51 @@ fn aiur_fn_393( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_393] = [__v_1]; - record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_1]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34441,15 +35705,15 @@ fn aiur_fn_393( }) } -const INPUT_SIZE_394: usize = 12; -const IN_394: usize = 12; -const OUT_394: usize = 1; -fn aiur_fn_394( - inp: [G; IN_394], +const INPUT_SIZE_393: usize = 12; +const IN_393: usize = 12; +const OUT_393: usize = 1; +fn aiur_fn_393( + inp: [G; IN_393], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_394], 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]; @@ -34465,43 +35729,51 @@ fn aiur_fn_394( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_394] = [__v_2]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_393] = [__v_2]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34511,39 +35783,40 @@ fn aiur_fn_394( }) } -const INPUT_SIZE_395: usize = 2; -const IN_395: usize = 2; -const OUT_395: usize = 1; -fn aiur_fn_395( - inp: [G; IN_395], +const INPUT_SIZE_394: usize = 2; +const IN_394: usize = 2; +const OUT_394: usize = 1; +fn aiur_fn_394( + inp: [G; IN_394], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_395], 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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_4]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_394] = [__v_4]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_396: usize = 2; -const IN_396: usize = 2; -const OUT_396: usize = 1; -fn aiur_fn_396( - inp: [G; IN_396], +const INPUT_SIZE_395: usize = 2; +const IN_395: usize = 2; +const OUT_395: usize = 1; +fn aiur_fn_395( + inp: [G; IN_395], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_396], 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]; @@ -34554,23 +35827,25 @@ fn aiur_fn_396( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_6]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_395] = [__v_6]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_12]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_395] = [__v_12]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -34589,23 +35864,24 @@ fn aiur_fn_396( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_310] = { let __args: [G; IN_310] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_22]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_395] = [__v_22]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -34615,14 +35891,15 @@ fn aiur_fn_396( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_12]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_395] = [__v_12]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -34632,10 +35909,11 @@ fn aiur_fn_396( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_17]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_395] = [__v_17]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34647,55 +35925,59 @@ fn aiur_fn_396( }, 4u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_11]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_395] = [__v_11]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_13]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_395] = [__v_13]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_8]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_395] = [__v_8]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_12]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_395] = [__v_12]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -34704,11 +35986,12 @@ fn aiur_fn_396( let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_12]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_395] = [__v_12]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34717,9 +36000,9 @@ fn aiur_fn_396( } }, 8u64 => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -34773,15 +36056,16 @@ fn aiur_fn_396( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_45]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_395] = [__v_45]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34806,19 +36090,19 @@ fn aiur_fn_396( }) } -const INPUT_SIZE_397: usize = 2; -const IN_397: usize = 2; -const OUT_397: usize = 1; -fn aiur_fn_397( - inp: [G; IN_397], +const INPUT_SIZE_396: usize = 2; +const IN_396: usize = 2; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: [G; IN_396], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_397], ExecError> { +) -> Result<[G; OUT_396], 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_395] = { let __args: [G; IN_395] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -34827,12 +36111,13 @@ fn aiur_fn_397( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_397] = [__v_4]; - record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_4]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -34841,8 +36126,9 @@ fn aiur_fn_397( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_397] = [__v_9]; - record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_9]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34854,23 +36140,24 @@ fn aiur_fn_397( }) } -const INPUT_SIZE_398: usize = 3; -const IN_398: usize = 3; -const OUT_398: usize = 1; -fn aiur_fn_398( - inp: [G; IN_398], +const INPUT_SIZE_397: usize = 3; +const IN_397: usize = 3; +const OUT_397: usize = 1; +fn aiur_fn_397( + inp: [G; IN_397], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_398], 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]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_398] = [__v_0]; - record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_397] = [__v_0]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34888,14 +36175,15 @@ fn aiur_fn_398( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_398] = { let __args: [G; IN_398] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_398] = [__v_14]; - record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_397] = [__v_14]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34912,15 +36200,15 @@ fn aiur_fn_398( }) } -const INPUT_SIZE_399: usize = 5; -const IN_399: usize = 5; -const OUT_399: usize = 1; -fn aiur_fn_399( - inp: [G; IN_399], +const INPUT_SIZE_398: usize = 5; +const IN_398: usize = 5; +const OUT_398: usize = 1; +fn aiur_fn_398( + inp: [G; IN_398], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_399], 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]; @@ -34937,22 +36225,24 @@ fn aiur_fn_399( let __v_9: G = (__v_1 - __v_2); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_399] = [__v_6]; - record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_398] = [__v_6]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); - let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_399] = { let __args: [G; IN_399] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_399] = [__v_16]; - record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_398] = [__v_16]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34964,15 +36254,15 @@ fn aiur_fn_399( }) } -const INPUT_SIZE_400: usize = 2; -const IN_400: usize = 2; -const OUT_400: usize = 1; -fn aiur_fn_400( - inp: [G; IN_400], +const INPUT_SIZE_399: usize = 2; +const IN_399: usize = 2; +const OUT_399: usize = 1; +fn aiur_fn_399( + inp: [G; IN_399], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_400], 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]; @@ -34989,14 +36279,16 @@ fn aiur_fn_400( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_400] = [__v_8]; - record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_399] = [__v_8]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_400] = [__v_8]; - record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_399] = [__v_8]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35009,25 +36301,28 @@ fn aiur_fn_400( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_400] = [__v_8]; - record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_399] = [__v_8]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_400] = [__v_9]; - record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_399] = [__v_9]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_400] = [__v_9]; - record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_399] = [__v_9]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35044,6 +36339,48 @@ fn aiur_fn_400( }) } +const INPUT_SIZE_400: usize = 3; +const IN_400: usize = 3; +const OUT_400: usize = 1; +fn aiur_fn_400( + inp: [G; IN_400], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_2: G = inp[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_400] = [__v_4]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_400] = [__v_8]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + } + }) +} + const INPUT_SIZE_401: usize = 3; const IN_401: usize = 3; const OUT_401: usize = 1; @@ -35057,27 +36394,22 @@ fn aiur_fn_401( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __v_3: G = (__v_0 - __v_1); + 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() { - 0u64 => { - let __v_4: G = G::from_u64(1); + 1u64 => { + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_4]; record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_8]; + let __ret: [G; OUT_401] = [__v_4]; record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35097,20 +36429,22 @@ fn aiur_fn_402( 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 }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; + let __v_4: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_4]; record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_402] = [__v_4]; record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35126,39 +36460,6 @@ fn aiur_fn_403( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; - let __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_403] = [__v_4]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_4]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }) -} - -const INPUT_SIZE_404: usize = 3; -const IN_404: usize = 3; -const OUT_404: usize = 1; -fn aiur_fn_404( - inp: [G; IN_404], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> 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]; @@ -35186,33 +36487,36 @@ fn aiur_fn_404( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_404] = [__v_17]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_17]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_405] = { let __args: [G; IN_405] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_20]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_20]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_404] = [__v_20]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_20]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35221,39 +36525,42 @@ fn aiur_fn_404( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_404] = [__v_16]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_16]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_404] = [__v_15]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_15]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_404] = [__v_11]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_11]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_405: usize = 3; -const IN_405: usize = 3; -const OUT_405: usize = 1; -fn aiur_fn_405( - inp: [G; IN_405], +const INPUT_SIZE_404: usize = 3; +const IN_404: usize = 3; +const OUT_404: usize = 1; +fn aiur_fn_404( + inp: [G; IN_404], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_405], 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]; @@ -35271,14 +36578,16 @@ fn aiur_fn_405( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_405] = [__v_9]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_405] = [__v_9]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35291,25 +36600,28 @@ fn aiur_fn_405( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_405] = [__v_9]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_405] = [__v_10]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_10]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_10]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_10]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35326,15 +36638,15 @@ fn aiur_fn_405( }) } -const INPUT_SIZE_406: usize = 1; -const IN_406: usize = 1; -const OUT_406: usize = 1; -fn aiur_fn_406( - inp: [G; IN_406], +const INPUT_SIZE_405: usize = 1; +const IN_405: usize = 1; +const OUT_405: usize = 1; +fn aiur_fn_405( + inp: [G; IN_405], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_406], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35348,14 +36660,16 @@ fn aiur_fn_406( 0u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_406] = [__v_5]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_5]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_406] = [__v_5]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_5]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35365,29 +36679,31 @@ fn aiur_fn_406( let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_406] = [__v_6]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_6]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_406] = [__v_5]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_5]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_407: usize = 1; -const IN_407: usize = 1; -const OUT_407: usize = 3; -fn aiur_fn_407( - inp: [G; IN_407], +const INPUT_SIZE_406: usize = 1; +const IN_406: usize = 1; +const OUT_406: usize = 3; +fn aiur_fn_406( + inp: [G; IN_406], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_407], ExecError> { +) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35402,20 +36718,22 @@ fn aiur_fn_407( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_407] = [__v_5, __v_9, __v_3]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_5, __v_9, __v_3]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_5, __v_0, __v_8]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_5, __v_0, __v_8]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35434,24 +36752,26 @@ fn aiur_fn_407( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __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_108] = { let __args: [G; IN_108] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_407] = [__v_14, __v_12, __v_15]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_14, __v_12, __v_15]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_11, __v_0, __v_14]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_11, __v_0, __v_14]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35479,7 +36799,7 @@ fn aiur_fn_407( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -35488,14 +36808,16 @@ fn aiur_fn_407( let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_407] = [__v_22, __v_20, __v_23]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_22, __v_20, __v_23]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_407] = [__v_22, __v_7, __v_17]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_22, __v_7, __v_17]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35504,9 +36826,10 @@ fn aiur_fn_407( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_19, __v_0, __v_22]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_19, __v_0, __v_22]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35515,9 +36838,10 @@ fn aiur_fn_407( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_19, __v_0, __v_22]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_19, __v_0, __v_22]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35526,9 +36850,10 @@ fn aiur_fn_407( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_15, __v_0, __v_18]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_15, __v_0, __v_18]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35537,9 +36862,10 @@ fn aiur_fn_407( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_13, __v_0, __v_16]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_13, __v_0, __v_16]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35548,9 +36874,10 @@ fn aiur_fn_407( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_9, __v_0, __v_12]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_9, __v_0, __v_12]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35559,47 +36886,49 @@ fn aiur_fn_407( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_5, __v_0, __v_8]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_406] = [__v_5, __v_0, __v_8]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_408: usize = 3; -const IN_408: usize = 3; -const OUT_408: usize = 2; -fn aiur_fn_408( - inp: [G; IN_408], +const INPUT_SIZE_407: usize = 3; +const IN_407: usize = 3; +const OUT_407: usize = 2; +fn aiur_fn_407( + inp: [G; IN_407], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_408], 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 __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __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_408] = [__v_6, __v_7]; - record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_6, __v_7]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __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_407] = { let __args: [G; IN_407] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -35608,27 +36937,30 @@ fn aiur_fn_408( 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_408] = [__v_13, __v_14]; - record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_13, __v_14]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_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_408] = [__v_14, __v_15]; - record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_14, __v_15]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_14, __v_15]; - record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_14, __v_15]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35639,48 +36971,50 @@ fn aiur_fn_408( }) } -const INPUT_SIZE_409: usize = 3; -const IN_409: usize = 3; -const OUT_409: usize = 1; -fn aiur_fn_409( - inp: [G; IN_409], +const INPUT_SIZE_408: usize = 3; +const IN_408: usize = 3; +const OUT_408: usize = 1; +fn aiur_fn_408( + inp: [G; IN_408], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_409], 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_410] = { let __args: [G; IN_410] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __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_409] = [__v_4]; - record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_408] = [__v_4]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_4]; - record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_408] = [__v_4]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_410: usize = 3; -const IN_410: usize = 3; -const OUT_410: usize = 1; -fn aiur_fn_410( - inp: [G; IN_410], +const INPUT_SIZE_409: usize = 3; +const IN_409: usize = 3; +const OUT_409: usize = 1; +fn aiur_fn_409( + inp: [G; IN_409], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_410], 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]; @@ -35698,113 +37032,122 @@ fn aiur_fn_410( let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_410] = [__v_9]; - record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_409] = [__v_9]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_410] = [__v_7]; - record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_409] = [__v_7]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_410] = [__v_7]; - record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_409] = [__v_7]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_411: usize = 3; -const IN_411: usize = 3; -const OUT_411: usize = 1; -fn aiur_fn_411( - inp: [G; IN_411], +const INPUT_SIZE_410: usize = 3; +const IN_410: usize = 3; +const OUT_410: usize = 1; +fn aiur_fn_410( + inp: [G; IN_410], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_411], 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 __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __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_411] = [__v_4]; - record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_410] = [__v_4]; + record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_411] = [__v_4]; - record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_410] = [__v_4]; + record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_412: usize = 3; -const IN_412: usize = 3; -const OUT_412: usize = 1; -fn aiur_fn_412( - inp: [G; IN_412], +const INPUT_SIZE_411: usize = 3; +const IN_411: usize = 3; +const OUT_411: usize = 1; +fn aiur_fn_411( + inp: [G; IN_411], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_412], ExecError> { +) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(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_386] = { let __args: [G; IN_386] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __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_412] = [__v_6]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_411] = [__v_6]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_7]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_411] = [__v_7]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_8]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_411] = [__v_8]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_8]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_411] = [__v_8]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35815,15 +37158,15 @@ fn aiur_fn_412( }) } -const INPUT_SIZE_413: usize = 3; -const IN_413: usize = 3; -const OUT_413: usize = 1; -fn aiur_fn_413( - inp: [G; IN_413], +const INPUT_SIZE_412: usize = 3; +const IN_412: usize = 3; +const OUT_412: usize = 1; +fn aiur_fn_412( + inp: [G; IN_412], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_413], 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]; @@ -35842,16 +37185,18 @@ fn aiur_fn_413( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_11]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_11]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_11]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_11]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35864,30 +37209,33 @@ fn aiur_fn_413( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_14]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_14]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_12]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_12]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_11]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_11]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35900,145 +37248,158 @@ fn aiur_fn_413( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_14]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_14]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_12]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_12]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_11]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_11]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_7]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_7]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_414: usize = 3; -const IN_414: usize = 3; -const OUT_414: usize = 1; -fn aiur_fn_414( - inp: [G; IN_414], +const INPUT_SIZE_413: usize = 3; +const IN_413: usize = 3; +const OUT_413: usize = 1; +fn aiur_fn_413( + inp: [G; IN_413], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_414], 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __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_414] = [__v_6]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_6]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_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].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_7]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __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_414] = [__v_8]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_8]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_414] = [__v_9]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_9]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_414] = [__v_10]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_10]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_414] = [__v_11]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_11]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_3, __v_4, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_3, __v_4, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_414] = [__v_14]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_14]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __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_414] = [__v_15]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_15]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_15]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_15]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36059,15 +37420,15 @@ fn aiur_fn_414( }) } -const INPUT_SIZE_415: usize = 3; -const IN_415: usize = 3; -const OUT_415: usize = 1; -fn aiur_fn_415( - inp: [G; IN_415], +const INPUT_SIZE_414: usize = 3; +const IN_414: usize = 3; +const OUT_414: usize = 1; +fn aiur_fn_414( + inp: [G; IN_414], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_415], 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]; @@ -36099,7 +37460,7 @@ fn aiur_fn_415( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); @@ -36130,42 +37491,46 @@ fn aiur_fn_415( match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_43]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_43]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_45]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_45]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_48]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_48]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_49]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_49]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36176,47 +37541,51 @@ fn aiur_fn_415( }, _ => { let __v_38: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_38]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_38]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_25]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_25]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_22]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_9]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_9]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_416: usize = 7; -const IN_416: usize = 7; -const OUT_416: usize = 1; -fn aiur_fn_416( - inp: [G; IN_416], +const INPUT_SIZE_415: usize = 7; +const IN_415: usize = 7; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: [G; IN_415], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_416], 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]; @@ -36229,32 +37598,35 @@ fn aiur_fn_416( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_8]; - record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_8]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_416] = [__v_13]; - record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_13]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_15]; - record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_15]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36263,15 +37635,15 @@ 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_416: usize = 2; +const IN_416: usize = 2; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: [G; IN_416], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_417], ExecError> { +) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36288,35 +37660,36 @@ fn aiur_fn_417( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_25]; - record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_416] = [__v_25]; + record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_418: usize = 3; -const IN_418: usize = 3; -const OUT_418: usize = 1; -fn aiur_fn_418( - inp: [G; IN_418], +const INPUT_SIZE_417: usize = 3; +const IN_417: usize = 3; +const OUT_417: usize = 1; +fn aiur_fn_417( + inp: [G; IN_417], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_418], 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]; @@ -36336,15 +37709,17 @@ fn aiur_fn_418( match __v_7.as_canonical_u64() { 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_11]; - record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_417] = [__v_11]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_11]; - record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_417] = [__v_11]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36357,16 +37732,18 @@ fn aiur_fn_418( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_11]; - record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_417] = [__v_11]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_11]; - record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_417] = [__v_11]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36375,54 +37752,56 @@ fn aiur_fn_418( }) } -const INPUT_SIZE_419: usize = 3; -const IN_419: usize = 3; -const OUT_419: usize = 1; -fn aiur_fn_419( - inp: [G; IN_419], +const INPUT_SIZE_418: usize = 3; +const IN_418: usize = 3; +const OUT_418: usize = 1; +fn aiur_fn_418( + inp: [G; IN_418], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_419], 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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __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_419] = [__v_6]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_418] = [__v_6]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_7]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_418] = [__v_7]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_420: usize = 1; -const IN_420: usize = 1; -const OUT_420: usize = 1; -fn aiur_fn_420( - inp: [G; IN_420], +const INPUT_SIZE_419: usize = 1; +const IN_419: usize = 1; +const OUT_419: usize = 1; +fn aiur_fn_419( + inp: [G; IN_419], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_420], ExecError> { +) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -36479,114 +37858,123 @@ fn aiur_fn_420( match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); - let __ret: [G; OUT_420] = [__v_36]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_36]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_36]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_36]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_36]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_36]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_22]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_22]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_20]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_20]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_20]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_20]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_7]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_7]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_421: usize = 3; -const IN_421: usize = 3; -const OUT_421: usize = 1; -fn aiur_fn_421( - inp: [G; IN_421], +const INPUT_SIZE_420: usize = 3; +const IN_420: usize = 3; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: [G; IN_420], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_421], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_421] = [__v_5]; - record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_5]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_6]; - record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_6]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_422: usize = 4; -const IN_422: usize = 4; -const OUT_422: usize = 1; -fn aiur_fn_422( - inp: [G; IN_422], +const INPUT_SIZE_421: usize = 4; +const IN_421: usize = 4; +const OUT_421: usize = 1; +fn aiur_fn_421( + inp: [G; IN_421], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_422], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -36595,62 +37983,65 @@ fn aiur_fn_422( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_422] = [__v_11]; - record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_421] = [__v_11]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_23]; - record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_421] = [__v_23]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_422] = [__v_10]; - record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_421] = [__v_10]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_422: usize = 2; +const IN_422: usize = 2; +const OUT_422: usize = 1; +fn aiur_fn_422( + inp: [G; IN_422], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_423], 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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -36666,58 +38057,62 @@ fn aiur_fn_423( match __v_8.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_423] = [__v_11]; - record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_422] = [__v_11]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_423] = [__v_11]; - record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_422] = [__v_11]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_423] = [__v_8]; - record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_422] = [__v_8]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_424: usize = 3; -const IN_424: usize = 3; -const OUT_424: usize = 1; -fn aiur_fn_424( - inp: [G; IN_424], +const INPUT_SIZE_423: usize = 3; +const IN_423: usize = 3; +const OUT_423: usize = 1; +fn aiur_fn_423( + inp: [G; IN_423], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_424], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_3]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_423] = [__v_3]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_424: usize = 3; +const IN_424: usize = 3; +const OUT_424: usize = 1; +fn aiur_fn_424( + inp: [G; IN_424], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_425], 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]; @@ -36740,22 +38135,25 @@ fn aiur_fn_425( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36768,16 +38166,18 @@ fn aiur_fn_425( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36794,26 +38194,29 @@ fn aiur_fn_425( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36826,31 +38229,34 @@ fn aiur_fn_425( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_13]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_13]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_425] = [__v_13]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_13]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36858,10 +38264,11 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36874,31 +38281,34 @@ fn aiur_fn_425( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_14]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_14]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36911,38 +38321,42 @@ fn aiur_fn_425( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_14]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_14]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_7]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_7]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -36953,28 +38367,31 @@ fn aiur_fn_425( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __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_425] = [__v_13]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_13]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_13]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_13]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36996,32 +38413,36 @@ fn aiur_fn_425( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_13]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_13]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_13]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_13]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_12]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_12]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_11]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_11]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37033,15 +38454,15 @@ fn aiur_fn_425( }) } -const INPUT_SIZE_426: usize = 4; -const IN_426: usize = 4; -const OUT_426: usize = 1; -fn aiur_fn_426( - inp: [G; IN_426], +const INPUT_SIZE_425: usize = 4; +const IN_425: usize = 4; +const OUT_425: usize = 1; +fn aiur_fn_425( + inp: [G; IN_425], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_426], 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]; @@ -37050,8 +38471,9 @@ fn aiur_fn_426( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_426] = [__v_4]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_4]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37059,44 +38481,48 @@ fn aiur_fn_426( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_426] = [__v_5]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_5]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __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_426] = [__v_10]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_10]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_5, __v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_10]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_10]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_9]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_9]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37104,17 +38530,19 @@ fn aiur_fn_426( _ => { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_9]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_9]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_9]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_9]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37127,15 +38555,15 @@ fn aiur_fn_426( }) } -const INPUT_SIZE_427: usize = 12; -const IN_427: usize = 12; -const OUT_427: usize = 1; -fn aiur_fn_427( - inp: [G; IN_427], +const INPUT_SIZE_426: usize = 12; +const IN_426: usize = 12; +const OUT_426: usize = 1; +fn aiur_fn_426( + inp: [G; IN_426], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_427], 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]; @@ -37151,29 +38579,31 @@ fn aiur_fn_427( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_427] = [__v_5]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_5]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_427] = [__v_12]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_12]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_428: usize = 6; -const IN_428: usize = 6; -const OUT_428: usize = 1; -fn aiur_fn_428( - inp: [G; IN_428], +const INPUT_SIZE_427: usize = 6; +const IN_427: usize = 6; +const OUT_427: usize = 1; +fn aiur_fn_427( + inp: [G; IN_427], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_428], 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]; @@ -37211,24 +38641,26 @@ fn aiur_fn_428( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __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_428] = [__v_34]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_34]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_34]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_34]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37236,41 +38668,45 @@ fn aiur_fn_428( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_34]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_34]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_37]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_37]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_38]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_38]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_38]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_38]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37283,147 +38719,154 @@ fn aiur_fn_428( }) } -const INPUT_SIZE_429: usize = 4; -const IN_429: usize = 4; -const OUT_429: usize = 1; -fn aiur_fn_429( - inp: [G; IN_429], +const INPUT_SIZE_428: usize = 4; +const IN_428: usize = 4; +const OUT_428: usize = 1; +fn aiur_fn_428( + inp: [G; IN_428], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_429], 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 __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __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_426] = { let __args: [G; IN_426] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_9]; - record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_9]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_429] = [__v_6]; - record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_6]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_430: usize = 4; -const IN_430: usize = 4; -const OUT_430: usize = 1; -fn aiur_fn_430( - inp: [G; IN_430], +const INPUT_SIZE_429: usize = 4; +const IN_429: usize = 4; +const OUT_429: usize = 1; +fn aiur_fn_429( + inp: [G; IN_429], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_430], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __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_426] = { let __args: [G; IN_426] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_9]; - record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_429] = [__v_9]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_430] = [__v_6]; - record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_429] = [__v_6]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_431: usize = 4; -const IN_431: usize = 4; -const OUT_431: usize = 1; -fn aiur_fn_431( - inp: [G; IN_431], +const INPUT_SIZE_430: usize = 4; +const IN_430: usize = 4; +const OUT_430: usize = 1; +fn aiur_fn_430( + inp: [G; IN_430], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_431], 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_437] = { let __args: [G; IN_437] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __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_426] = { let __args: [G; IN_426] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_431] = [__v_12]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_430] = [__v_12]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_8]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_430] = [__v_8]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_6]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_430] = [__v_6]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_432: usize = 5; -const IN_432: usize = 5; -const OUT_432: usize = 1; -fn aiur_fn_432( - inp: [G; IN_432], +const INPUT_SIZE_431: usize = 5; +const IN_431: usize = 5; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: [G; IN_431], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_432], 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]; @@ -37445,73 +38888,79 @@ fn aiur_fn_432( let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_432] = [__v_19]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_19]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_432] = [__v_23]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_23]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_21, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __v_21, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_25]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_25]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __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_401] = { let __args: [G; IN_401] = [__v_22, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_22, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); - let __ret: [G; OUT_432] = [__v_24]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_24]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = (__v_3 - __v_24); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_22, __v_2, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_22, __v_2, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_26]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_26]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_432] = [__v_23]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_23]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37522,15 +38971,15 @@ fn aiur_fn_432( }) } -const INPUT_SIZE_433: usize = 5; -const IN_433: usize = 5; -const OUT_433: usize = 1; -fn aiur_fn_433( - inp: [G; IN_433], +const INPUT_SIZE_432: usize = 5; +const IN_432: usize = 5; +const OUT_432: usize = 1; +fn aiur_fn_432( + inp: [G; IN_432], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_433], 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]; @@ -37552,73 +39001,79 @@ fn aiur_fn_433( let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_433] = [__v_19]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_19]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_21, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_23]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_23]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_21, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_21, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_25]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_25]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __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_401] = { let __args: [G; IN_401] = [__v_1, __v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_24]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_24]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = (__v_3 - __v_24); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_22, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __v_22, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_26]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_26]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_433] = [__v_23]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_23]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37629,71 +39084,75 @@ fn aiur_fn_433( }) } -const INPUT_SIZE_434: usize = 4; -const IN_434: usize = 4; -const OUT_434: usize = 1; -fn aiur_fn_434( - inp: [G; IN_434], +const INPUT_SIZE_433: usize = 4; +const IN_433: usize = 4; +const OUT_433: usize = 1; +fn aiur_fn_433( + inp: [G; IN_433], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_434], 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 __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_434] = [__v_11]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_11]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 - __v_11); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_9, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_9, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_13]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_13]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_434] = [__v_10]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_10]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_12]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_12]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37703,32 +39162,35 @@ fn aiur_fn_434( _ => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_434] = [__v_10]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_10]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_8, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_8, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_12]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_12]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_8]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_8]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37737,15 +39199,15 @@ fn aiur_fn_434( }) } -const INPUT_SIZE_435: usize = 12; -const IN_435: usize = 12; -const OUT_435: usize = 1; -fn aiur_fn_435( - inp: [G; IN_435], +const INPUT_SIZE_434: usize = 12; +const IN_434: usize = 12; +const OUT_434: usize = 1; +fn aiur_fn_434( + inp: [G; IN_434], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_435], 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]; @@ -37762,35 +39224,38 @@ fn aiur_fn_435( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_435] = [__v_12]; - record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_12]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_435] = [__v_12]; - record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_12]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_435] = [__v_12]; - record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_12]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_436: usize = 1; -const IN_436: usize = 1; -const OUT_436: usize = 2; -fn aiur_fn_436( - inp: [G; IN_436], +const INPUT_SIZE_435: usize = 1; +const IN_435: usize = 1; +const OUT_435: usize = 2; +fn aiur_fn_435( + inp: [G; IN_435], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_436], ExecError> { +) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -37803,24 +39268,105 @@ fn aiur_fn_436( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(8); - let __v_10: G = { let __values: [G; 4] = [__v_9, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_11, __v_12]; - record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_435] = [__v_11, __v_12]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_436] = [__v_9, __v_0]; + let __ret: [G; OUT_435] = [__v_9, __v_0]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_435] = [__v_7, __v_0]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_436: usize = 1; +const IN_436: usize = 1; +const OUT_436: usize = 2; +fn aiur_fn_436( + inp: [G; IN_436], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_436], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __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_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + let __v_19: G = __loaded[11]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_21, __v_22]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_21, __v_22]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_436] = [__v_20, __v_0]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37829,119 +39375,47 @@ fn aiur_fn_436( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_436] = [__v_7, __v_0]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_437: usize = 1; -const IN_437: usize = 1; -const OUT_437: usize = 2; +const INPUT_SIZE_437: usize = 3; +const IN_437: usize = 3; +const OUT_437: usize = 1; fn aiur_fn_437( inp: [G; IN_437], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_437], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __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_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; - let __v_8: G = __loaded[0]; - let __v_9: G = __loaded[1]; - let __v_10: G = __loaded[2]; - let __v_11: G = __loaded[3]; - let __v_12: G = __loaded[4]; - let __v_13: G = __loaded[5]; - let __v_14: G = __loaded[6]; - let __v_15: G = __loaded[7]; - let __v_16: G = __loaded[8]; - let __v_17: G = __loaded[9]; - let __v_18: G = __loaded[10]; - let __v_19: G = __loaded[11]; - match __v_8.as_canonical_u64() { - 1u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; - let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_21, __v_22]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 2u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; - let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_21, __v_22]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_20, __v_0]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }, - _ => { - let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_7, __v_0]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }) -} - -const INPUT_SIZE_438: usize = 3; -const IN_438: usize = 3; -const OUT_438: usize = 1; -fn aiur_fn_438( - inp: [G; IN_438], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __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_438] = [__v_7]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_7]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_438] = [__v_7]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_7]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37975,27 +39449,29 @@ fn aiur_fn_438( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __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_401] = { let __args: [G; IN_401] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_37]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_37]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_37]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_37]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38003,16 +39479,18 @@ fn aiur_fn_438( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_37]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_37]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_438] = [__v_37]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_37]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38028,15 +39506,15 @@ fn aiur_fn_438( }) } -const INPUT_SIZE_439: usize = 1; -const IN_439: usize = 1; -const OUT_439: usize = 2; -fn aiur_fn_439( - inp: [G; IN_439], +const INPUT_SIZE_438: usize = 1; +const IN_438: usize = 1; +const OUT_438: usize = 2; +fn aiur_fn_438( + inp: [G; IN_438], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_439], ExecError> { +) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -38050,8 +39528,9 @@ fn aiur_fn_439( match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_439] = [__v_4, __v_7]; - record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_4, __v_7]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38087,25 +39566,26 @@ fn aiur_fn_439( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_40: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_39, __v_40]; - record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_39, __v_40]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_440: usize = 14; -const IN_440: usize = 14; -const OUT_440: usize = 2; -fn aiur_fn_440( - inp: [G; IN_440], +const INPUT_SIZE_439: usize = 14; +const IN_439: usize = 14; +const OUT_439: usize = 2; +fn aiur_fn_439( + inp: [G; IN_439], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_440], 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]; @@ -38123,90 +39603,96 @@ fn aiur_fn_440( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_16, __v_17]; - record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_439] = [__v_16, __v_17]; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_440] = [__v_16, __v_0]; - record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_439] = [__v_16, __v_0]; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_384] = { let __args: [G; IN_384] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_16, __v_17]; - record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_439] = [__v_16, __v_17]; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_440] = [__v_16, __v_0]; - record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_439] = [__v_16, __v_0]; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_440] = [__v_14, __v_0]; - record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_439] = [__v_14, __v_0]; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_441: usize = 2; -const IN_441: usize = 2; -const OUT_441: usize = 1; -fn aiur_fn_441( - inp: [G; IN_441], +const INPUT_SIZE_440: usize = 2; +const IN_440: usize = 2; +const OUT_440: usize = 1; +fn aiur_fn_440( + inp: [G; IN_440], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_441], 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_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_4]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_440] = [__v_4]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_442: usize = 2; -const IN_442: usize = 2; -const OUT_442: usize = 1; -fn aiur_fn_442( - inp: [G; IN_442], +const INPUT_SIZE_441: usize = 2; +const IN_441: usize = 2; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: [G; IN_441], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_442], 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]; @@ -38217,23 +39703,25 @@ fn aiur_fn_442( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_6]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_441] = [__v_6]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_12]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_441] = [__v_12]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -38252,91 +39740,98 @@ fn aiur_fn_442( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __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_310] = { let __args: [G; IN_310] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_22]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_441] = [__v_22]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_12]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_441] = [__v_12]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_12]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_441] = [__v_12]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_13]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_441] = [__v_13]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_9]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_441] = [__v_9]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_6]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_441] = [__v_6]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_6]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_441] = [__v_6]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38346,15 +39841,15 @@ fn aiur_fn_442( }) } -const INPUT_SIZE_443: usize = 4; -const IN_443: usize = 4; -const OUT_443: usize = 1; -fn aiur_fn_443( - inp: [G; IN_443], +const INPUT_SIZE_442: usize = 4; +const IN_442: usize = 4; +const OUT_442: usize = 1; +fn aiur_fn_442( + inp: [G; IN_442], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_443], 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]; @@ -38366,20 +39861,22 @@ fn aiur_fn_443( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_443] = [__v_0]; - record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_0]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_9]; - record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_9]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38392,7 +39889,7 @@ fn aiur_fn_443( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -38400,24 +39897,25 @@ fn aiur_fn_443( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_15]; - record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_15]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -38425,14 +39923,14 @@ fn aiur_fn_443( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -38441,16 +39939,17 @@ fn aiur_fn_443( let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_23]; - record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_23]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38467,30 +39966,31 @@ fn aiur_fn_443( }) } -const INPUT_SIZE_444: usize = 2; -const IN_444: usize = 2; -const OUT_444: usize = 1; -fn aiur_fn_444( - inp: [G; IN_444], +const INPUT_SIZE_443: usize = 2; +const IN_443: usize = 2; +const OUT_443: usize = 1; +fn aiur_fn_443( + inp: [G; IN_443], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_444], 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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_444] = [__v_8]; - record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_443] = [__v_8]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -38499,11 +39999,12 @@ fn aiur_fn_444( let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_444] = [__v_8]; - record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_443] = [__v_8]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38513,23 +40014,23 @@ fn aiur_fn_444( }) } -const INPUT_SIZE_445: usize = 4; -const IN_445: usize = 4; -const OUT_445: usize = 1; -fn aiur_fn_445( - inp: [G; IN_445], +const INPUT_SIZE_444: usize = 4; +const IN_444: usize = 4; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: [G; IN_444], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_445], 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]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -38540,11 +40041,12 @@ fn aiur_fn_445( 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_13]; - record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_444] = [__v_13]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38554,29 +40056,30 @@ fn aiur_fn_445( }) } -const INPUT_SIZE_446: usize = 3; -const IN_446: usize = 3; -const OUT_446: usize = 1; -fn aiur_fn_446( - inp: [G; IN_446], +const INPUT_SIZE_445: usize = 3; +const IN_445: usize = 3; +const OUT_445: usize = 1; +fn aiur_fn_445( + inp: [G; IN_445], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_446], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_3]; - record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_445] = [__v_3]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -38586,18 +40089,20 @@ fn aiur_fn_446( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_12]; - record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_445] = [__v_12]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_446] = [__v_3]; - record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_445] = [__v_3]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38606,54 +40111,56 @@ fn aiur_fn_446( }) } -const INPUT_SIZE_447: usize = 3; -const IN_447: usize = 3; -const OUT_447: usize = 0; -fn aiur_fn_447( - inp: [G; IN_447], +const INPUT_SIZE_446: usize = 3; +const IN_446: usize = 3; +const OUT_446: usize = 0; +fn aiur_fn_446( + inp: [G; IN_446], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_447], 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]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_447] = []; - record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_446] = []; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_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_447] = []; - record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_446] = []; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_448: usize = 4; -const IN_448: usize = 4; -const OUT_448: usize = 0; -fn aiur_fn_448( - inp: [G; IN_448], +const INPUT_SIZE_447: usize = 4; +const IN_447: usize = 4; +const OUT_447: usize = 0; +fn aiur_fn_447( + inp: [G; IN_447], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_448], 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]; @@ -38661,33 +40168,36 @@ fn aiur_fn_448( let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_448] = []; - record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_448] = []; - record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_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_448] = []; - record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38696,15 +40206,15 @@ fn aiur_fn_448( }) } -const INPUT_SIZE_449: usize = 7; -const IN_449: usize = 7; -const OUT_449: usize = 1; -fn aiur_fn_449( - inp: [G; IN_449], +const INPUT_SIZE_448: usize = 7; +const IN_448: usize = 7; +const OUT_448: usize = 1; +fn aiur_fn_448( + inp: [G; IN_448], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_449], 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]; @@ -38723,24 +40233,26 @@ fn aiur_fn_449( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_449] = [__v_8]; - record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_448] = [__v_8]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_449] = { let __args: [G; IN_449] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_18]; - record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_448] = [__v_18]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38752,23 +40264,23 @@ fn aiur_fn_449( }) } -const INPUT_SIZE_450: usize = 4; -const IN_450: usize = 4; -const OUT_450: usize = 1; -fn aiur_fn_450( - inp: [G; IN_450], +const INPUT_SIZE_449: usize = 4; +const IN_449: usize = 4; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: [G; IN_449], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_450], 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 __v_3: G = inp[3]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -38822,18 +40334,19 @@ fn aiur_fn_450( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_450] = [__v_45]; - record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_449] = [__v_45]; + record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38853,21 +40366,21 @@ fn aiur_fn_450( }) } -const INPUT_SIZE_451: usize = 2; -const IN_451: usize = 2; -const OUT_451: usize = 1; -fn aiur_fn_451( - inp: [G; IN_451], +const INPUT_SIZE_450: usize = 2; +const IN_450: usize = 2; +const OUT_450: usize = 1; +fn aiur_fn_450( + inp: [G; IN_450], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_451], ExecError> { +) -> Result<[G; OUT_450], 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_441] = { let __args: [G; IN_441] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -38876,8 +40389,9 @@ fn aiur_fn_451( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_451] = [__v_5]; - record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_450] = [__v_5]; + record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38887,29 +40401,80 @@ fn aiur_fn_451( }) } -const INPUT_SIZE_452: usize = 3; -const IN_452: usize = 3; -const OUT_452: usize = 0; -fn aiur_fn_452( - inp: [G; IN_452], +const INPUT_SIZE_451: usize = 3; +const IN_451: usize = 3; +const OUT_451: usize = 0; +fn aiur_fn_451( + inp: [G; IN_451], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_452], ExecError> { +) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(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_441] = { let __args: [G; IN_441] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_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_452] = []; + let __ret: [G; OUT_451] = []; + record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_452: usize = 0; +const IN_452: usize = 0; +const OUT_452: usize = 1; +fn aiur_fn_452( + inp: [G; IN_452], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_452], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(236); + let __v_1: G = G::from_u64(31); + let __v_2: G = G::from_u64(96); + let __v_3: G = G::from_u64(193); + let __v_4: G = G::from_u64(162); + let __v_5: G = G::from_u64(141); + let __v_6: G = G::from_u64(72); + let __v_7: G = G::from_u64(188); + let __v_8: G = G::from_u64(152); + let __v_9: G = G::from_u64(254); + let __v_10: G = G::from_u64(62); + let __v_11: G = G::from_u64(247); + let __v_12: G = G::from_u64(45); + let __v_13: G = G::from_u64(37); + let __v_14: G = G::from_u64(81); + let __v_15: G = G::from_u64(50); + let __v_16: G = G::from_u64(115); + let __v_17: G = G::from_u64(90); + let __v_18: G = G::from_u64(80); + let __v_19: G = G::from_u64(60); + let __v_20: G = G::from_u64(195); + let __v_21: G = G::from_u64(110); + let __v_22: G = G::from_u64(63); + let __v_23: G = G::from_u64(240); + let __v_24: G = G::from_u64(242); + let __v_25: G = G::from_u64(46); + let __v_26: G = G::from_u64(61); + let __v_27: G = G::from_u64(72); + let __v_28: G = G::from_u64(110); + let __v_29: G = G::from_u64(38); + let __v_30: G = G::from_u64(110); + let __v_31: G = G::from_u64(190); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_452] = [__v_32]; record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -38924,41 +40489,42 @@ fn aiur_fn_453( unconstrained: bool, ) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(8); - let __v_1: G = G::from_u64(250); - let __v_2: G = G::from_u64(173); - let __v_3: G = G::from_u64(94); - let __v_4: G = G::from_u64(146); - let __v_5: G = G::from_u64(49); - let __v_6: G = G::from_u64(110); - let __v_7: G = G::from_u64(23); - let __v_8: G = G::from_u64(229); - let __v_9: G = G::from_u64(248); - let __v_10: G = G::from_u64(8); - let __v_11: G = G::from_u64(4); - let __v_12: G = G::from_u64(152); - let __v_13: G = G::from_u64(44); - let __v_14: G = G::from_u64(111); - let __v_15: G = G::from_u64(133); - let __v_16: G = G::from_u64(62); - let __v_17: G = G::from_u64(50); - let __v_18: G = G::from_u64(188); - let __v_19: G = G::from_u64(67); - let __v_20: G = G::from_u64(244); - let __v_21: G = G::from_u64(220); - let __v_22: G = G::from_u64(65); - let __v_23: G = G::from_u64(6); - let __v_24: G = G::from_u64(25); - let __v_25: G = G::from_u64(236); - let __v_26: G = G::from_u64(19); - let __v_27: G = G::from_u64(223); - let __v_28: G = G::from_u64(21); - let __v_29: G = G::from_u64(35); - let __v_30: G = G::from_u64(119); - let __v_31: G = G::from_u64(227); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(180); + let __v_1: G = G::from_u64(178); + let __v_2: G = G::from_u64(108); + let __v_3: G = G::from_u64(46); + let __v_4: G = G::from_u64(41); + let __v_5: G = G::from_u64(147); + let __v_6: G = G::from_u64(28); + let __v_7: G = G::from_u64(6); + let __v_8: G = G::from_u64(232); + let __v_9: G = G::from_u64(133); + let __v_10: G = G::from_u64(145); + let __v_11: G = G::from_u64(70); + let __v_12: G = G::from_u64(19); + let __v_13: G = G::from_u64(250); + let __v_14: G = G::from_u64(255); + let __v_15: G = G::from_u64(88); + let __v_16: G = G::from_u64(86); + let __v_17: G = G::from_u64(19); + let __v_18: G = G::from_u64(142); + let __v_19: G = G::from_u64(92); + let __v_20: G = G::from_u64(176); + let __v_21: G = G::from_u64(150); + let __v_22: G = G::from_u64(32); + let __v_23: G = G::from_u64(221); + let __v_24: G = G::from_u64(182); + let __v_25: G = G::from_u64(146); + let __v_26: G = G::from_u64(26); + let __v_27: G = G::from_u64(52); + let __v_28: G = G::from_u64(45); + let __v_29: G = G::from_u64(237); + let __v_30: G = G::from_u64(137); + let __v_31: G = G::from_u64(87); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_453] = [__v_32]; record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -38973,41 +40539,42 @@ fn aiur_fn_454( unconstrained: bool, ) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(103); - let __v_1: G = G::from_u64(110); - let __v_2: G = G::from_u64(135); - let __v_3: G = G::from_u64(221); - let __v_4: G = G::from_u64(229); - let __v_5: G = G::from_u64(207); - let __v_6: G = G::from_u64(48); - let __v_7: G = G::from_u64(192); - let __v_8: G = G::from_u64(1); - let __v_9: G = G::from_u64(105); - let __v_10: G = G::from_u64(11); - let __v_11: G = G::from_u64(187); - let __v_12: G = G::from_u64(231); - let __v_13: G = G::from_u64(171); - let __v_14: G = G::from_u64(116); - let __v_15: G = G::from_u64(252); - let __v_16: G = G::from_u64(169); - let __v_17: G = G::from_u64(43); - let __v_18: G = G::from_u64(10); - let __v_19: G = G::from_u64(166); - let __v_20: G = G::from_u64(18); - let __v_21: G = G::from_u64(237); - let __v_22: G = G::from_u64(158); - let __v_23: G = G::from_u64(243); - let __v_24: G = G::from_u64(202); - let __v_25: G = G::from_u64(248); - let __v_26: G = G::from_u64(159); - let __v_27: G = G::from_u64(29); - let __v_28: G = G::from_u64(158); - let __v_29: G = G::from_u64(106); - let __v_30: G = G::from_u64(36); - let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(192); + let __v_1: G = G::from_u64(19); + let __v_2: G = G::from_u64(193); + let __v_3: G = G::from_u64(83); + let __v_4: G = G::from_u64(235); + let __v_5: G = G::from_u64(240); + let __v_6: G = G::from_u64(32); + let __v_7: G = G::from_u64(40); + let __v_8: G = G::from_u64(174); + let __v_9: G = G::from_u64(210); + let __v_10: G = G::from_u64(100); + let __v_11: G = G::from_u64(51); + let __v_12: G = G::from_u64(60); + let __v_13: G = G::from_u64(30); + let __v_14: G = G::from_u64(76); + let __v_15: G = G::from_u64(133); + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(125); + let __v_18: G = G::from_u64(11); + let __v_19: G = G::from_u64(135); + let __v_20: G = G::from_u64(2); + let __v_21: G = G::from_u64(93); + let __v_22: G = G::from_u64(117); + let __v_23: G = G::from_u64(150); + let __v_24: G = G::from_u64(169); + let __v_25: G = G::from_u64(105); + let __v_26: G = G::from_u64(113); + let __v_27: G = G::from_u64(187); + let __v_28: G = G::from_u64(43); + let __v_29: G = G::from_u64(103); + let __v_30: G = G::from_u64(146); + let __v_31: G = G::from_u64(29); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_454] = [__v_32]; record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39021,55 +40588,6 @@ fn aiur_fn_455( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_455], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(204); - let __v_1: G = G::from_u64(225); - let __v_2: G = G::from_u64(37); - let __v_3: G = G::from_u64(101); - let __v_4: G = G::from_u64(11); - let __v_5: G = G::from_u64(119); - let __v_6: G = G::from_u64(93); - let __v_7: G = G::from_u64(25); - let __v_8: G = G::from_u64(16); - let __v_9: G = G::from_u64(239); - let __v_10: G = G::from_u64(234); - let __v_11: G = G::from_u64(145); - let __v_12: G = G::from_u64(159); - let __v_13: G = G::from_u64(92); - let __v_14: G = G::from_u64(242); - let __v_15: G = G::from_u64(114); - let __v_16: G = G::from_u64(247); - let __v_17: G = G::from_u64(217); - let __v_18: G = G::from_u64(231); - let __v_19: G = G::from_u64(177); - let __v_20: G = G::from_u64(29); - let __v_21: G = G::from_u64(98); - let __v_22: G = G::from_u64(52); - let __v_23: G = G::from_u64(61); - let __v_24: G = G::from_u64(109); - let __v_25: G = G::from_u64(10); - let __v_26: G = G::from_u64(88); - let __v_27: G = G::from_u64(156); - let __v_28: G = G::from_u64(223); - let __v_29: G = G::from_u64(174); - let __v_30: G = G::from_u64(255); - let __v_31: G = G::from_u64(33); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_455] = [__v_32]; - record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - -const INPUT_SIZE_456: usize = 0; -const IN_456: usize = 0; -const OUT_456: usize = 1; -fn aiur_fn_456( - inp: [G; IN_456], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(158); @@ -39103,22 +40621,23 @@ fn aiur_fn_456( let __v_29: G = G::from_u64(169); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(129); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_456] = [__v_32]; - record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_455] = [__v_32]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_457: usize = 0; -const IN_457: usize = 0; -const OUT_457: usize = 1; -fn aiur_fn_457( - inp: [G; IN_457], +const INPUT_SIZE_456: usize = 0; +const IN_456: usize = 0; +const OUT_456: usize = 1; +fn aiur_fn_456( + inp: [G; IN_456], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_457], ExecError> { +) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(113); @@ -39152,9 +40671,60 @@ fn aiur_fn_457( let __v_29: G = G::from_u64(188); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(149); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_456] = [__v_32]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_457: usize = 0; +const IN_457: usize = 0; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_457], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(33); + let __v_1: G = G::from_u64(224); + let __v_2: G = G::from_u64(224); + let __v_3: G = G::from_u64(120); + let __v_4: G = G::from_u64(59); + let __v_5: G = G::from_u64(118); + let __v_6: G = G::from_u64(23); + let __v_7: G = G::from_u64(176); + let __v_8: G = G::from_u64(204); + let __v_9: G = G::from_u64(78); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(77); + let __v_12: G = G::from_u64(31); + let __v_13: G = G::from_u64(171); + let __v_14: G = G::from_u64(124); + let __v_15: G = G::from_u64(255); + let __v_16: G = G::from_u64(239); + let __v_17: G = G::from_u64(224); + let __v_18: G = G::from_u64(28); + let __v_19: G = G::from_u64(212); + let __v_20: G = G::from_u64(61); + let __v_21: G = G::from_u64(167); + let __v_22: G = G::from_u64(126); + let __v_23: G = G::from_u64(47); + let __v_24: G = G::from_u64(152); + let __v_25: G = G::from_u64(209); + let __v_26: G = G::from_u64(80); + let __v_27: G = G::from_u64(148); + let __v_28: G = G::from_u64(160); + let __v_29: G = G::from_u64(216); + let __v_30: G = G::from_u64(240); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_457] = [__v_32]; record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39169,41 +40739,42 @@ fn aiur_fn_458( unconstrained: bool, ) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(203); - let __v_1: G = G::from_u64(31); - let __v_2: G = G::from_u64(165); - let __v_3: G = G::from_u64(173); - let __v_4: G = G::from_u64(62); - let __v_5: G = G::from_u64(99); - let __v_6: G = G::from_u64(44); - let __v_7: G = G::from_u64(7); - let __v_8: G = G::from_u64(180); - let __v_9: G = G::from_u64(136); - let __v_10: G = G::from_u64(40); - let __v_11: G = G::from_u64(175); - let __v_12: G = G::from_u64(96); - let __v_13: G = G::from_u64(79); - let __v_14: G = G::from_u64(115); - let __v_15: G = G::from_u64(199); - let __v_16: G = G::from_u64(10); - let __v_17: G = G::from_u64(130); - let __v_18: G = G::from_u64(11); - let __v_19: G = G::from_u64(29); - let __v_20: G = G::from_u64(228); - let __v_21: G = G::from_u64(161); - let __v_22: G = G::from_u64(59); - let __v_23: G = G::from_u64(171); - let __v_24: G = G::from_u64(243); - let __v_25: G = G::from_u64(31); - let __v_26: G = G::from_u64(43); - let __v_27: G = G::from_u64(120); - let __v_28: G = G::from_u64(150); - let __v_29: G = G::from_u64(247); - let __v_30: G = G::from_u64(249); - let __v_31: G = G::from_u64(186); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(1); + let __v_1: G = G::from_u64(131); + let __v_2: G = G::from_u64(89); + let __v_3: G = G::from_u64(91); + let __v_4: G = G::from_u64(131); + let __v_5: G = G::from_u64(123); + let __v_6: G = G::from_u64(155); + let __v_7: G = G::from_u64(132); + let __v_8: G = G::from_u64(218); + let __v_9: G = G::from_u64(95); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(75); + let __v_12: G = G::from_u64(138); + let __v_13: G = G::from_u64(196); + let __v_14: G = G::from_u64(164); + let __v_15: G = G::from_u64(187); + let __v_16: G = G::from_u64(211); + let __v_17: G = G::from_u64(188); + let __v_18: G = G::from_u64(6); + let __v_19: G = G::from_u64(40); + let __v_20: G = G::from_u64(185); + let __v_21: G = G::from_u64(156); + let __v_22: G = G::from_u64(141); + let __v_23: G = G::from_u64(85); + let __v_24: G = G::from_u64(14); + let __v_25: G = G::from_u64(179); + let __v_26: G = G::from_u64(81); + let __v_27: G = G::from_u64(247); + let __v_28: G = G::from_u64(76); + let __v_29: G = G::from_u64(225); + let __v_30: G = G::from_u64(109); + let __v_31: G = G::from_u64(72); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_458] = [__v_32]; record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39218,41 +40789,42 @@ fn aiur_fn_459( unconstrained: bool, ) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(234); - let __v_1: G = G::from_u64(117); - let __v_2: G = G::from_u64(97); - let __v_3: G = G::from_u64(219); - let __v_4: G = G::from_u64(37); - let __v_5: G = G::from_u64(170); - let __v_6: G = G::from_u64(36); - let __v_7: G = G::from_u64(206); - let __v_8: G = G::from_u64(72); - let __v_9: G = G::from_u64(28); - let __v_10: G = G::from_u64(227); - let __v_11: G = G::from_u64(233); - let __v_12: G = G::from_u64(238); - let __v_13: G = G::from_u64(141); - let __v_14: G = G::from_u64(112); - let __v_15: G = G::from_u64(77); - let __v_16: G = G::from_u64(72); - let __v_17: G = G::from_u64(61); - let __v_18: G = G::from_u64(217); - let __v_19: G = G::from_u64(5); - let __v_20: G = G::from_u64(103); - let __v_21: G = G::from_u64(87); - let __v_22: G = G::from_u64(218); - let __v_23: G = G::from_u64(126); - let __v_24: G = G::from_u64(218); - let __v_25: G = G::from_u64(36); - let __v_26: G = G::from_u64(181); - let __v_27: G = G::from_u64(17); - let __v_28: G = G::from_u64(27); - let __v_29: G = G::from_u64(229); - let __v_30: G = G::from_u64(155); - let __v_31: G = G::from_u64(194); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(156); + let __v_1: G = G::from_u64(230); + let __v_2: G = G::from_u64(227); + let __v_3: G = G::from_u64(34); + let __v_4: G = G::from_u64(241); + let __v_5: G = G::from_u64(148); + let __v_6: G = G::from_u64(129); + let __v_7: G = G::from_u64(242); + let __v_8: G = G::from_u64(28); + let __v_9: G = G::from_u64(244); + let __v_10: G = G::from_u64(196); + let __v_11: G = G::from_u64(143); + let __v_12: G = G::from_u64(136); + let __v_13: G = G::from_u64(120); + let __v_14: G = G::from_u64(152); + let __v_15: G = G::from_u64(118); + let __v_16: G = G::from_u64(182); + let __v_17: G = G::from_u64(155); + let __v_18: G = G::from_u64(138); + let __v_19: G = G::from_u64(155); + let __v_20: G = G::from_u64(21); + let __v_21: G = G::from_u64(32); + let __v_22: G = G::from_u64(67); + let __v_23: G = G::from_u64(156); + let __v_24: G = G::from_u64(16); + let __v_25: G = G::from_u64(29); + let __v_26: G = G::from_u64(152); + let __v_27: G = G::from_u64(63); + let __v_28: G = G::from_u64(150); + let __v_29: G = G::from_u64(234); + let __v_30: G = G::from_u64(96); + let __v_31: G = G::from_u64(183); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_459] = [__v_32]; record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39267,41 +40839,42 @@ fn aiur_fn_460( unconstrained: bool, ) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(203); - let __v_1: G = G::from_u64(15); - let __v_2: G = G::from_u64(240); - let __v_3: G = G::from_u64(125); - let __v_4: G = G::from_u64(63); - let __v_5: G = G::from_u64(114); - let __v_6: G = G::from_u64(38); - let __v_7: G = G::from_u64(168); - let __v_8: G = G::from_u64(152); - let __v_9: G = G::from_u64(118); - let __v_10: G = G::from_u64(157); - let __v_11: G = G::from_u64(168); - let __v_12: G = G::from_u64(202); - let __v_13: G = G::from_u64(172); - let __v_14: G = G::from_u64(154); - let __v_15: G = G::from_u64(193); - let __v_16: G = G::from_u64(180); - let __v_17: G = G::from_u64(146); - let __v_18: G = G::from_u64(38); - let __v_19: G = G::from_u64(214); - let __v_20: G = G::from_u64(174); - let __v_21: G = G::from_u64(67); - let __v_22: G = G::from_u64(178); - let __v_23: G = G::from_u64(175); - let __v_24: G = G::from_u64(252); - let __v_25: G = G::from_u64(132); - let __v_26: G = G::from_u64(154); - let __v_27: G = G::from_u64(151); - let __v_28: G = G::from_u64(249); - let __v_29: G = G::from_u64(211); - let __v_30: G = G::from_u64(229); - let __v_31: G = G::from_u64(199); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(60); + let __v_1: G = G::from_u64(245); + let __v_2: G = G::from_u64(77); + let __v_3: G = G::from_u64(51); + let __v_4: G = G::from_u64(56); + let __v_5: G = G::from_u64(33); + let __v_6: G = G::from_u64(221); + let __v_7: G = G::from_u64(55); + let __v_8: G = G::from_u64(104); + let __v_9: G = G::from_u64(58); + let __v_10: G = G::from_u64(11); + let __v_11: G = G::from_u64(243); + let __v_12: G = G::from_u64(135); + let __v_13: G = G::from_u64(57); + let __v_14: G = G::from_u64(230); + let __v_15: G = G::from_u64(135); + let __v_16: G = G::from_u64(97); + let __v_17: G = G::from_u64(10); + let __v_18: G = G::from_u64(25); + let __v_19: G = G::from_u64(145); + let __v_20: G = G::from_u64(117); + let __v_21: G = G::from_u64(146); + let __v_22: G = G::from_u64(32); + let __v_23: G = G::from_u64(183); + let __v_24: G = G::from_u64(126); + let __v_25: G = G::from_u64(222); + let __v_26: G = G::from_u64(195); + let __v_27: G = G::from_u64(56); + let __v_28: G = G::from_u64(186); + let __v_29: G = G::from_u64(60); + let __v_30: G = G::from_u64(251); + let __v_31: G = G::from_u64(200); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_460] = [__v_32]; record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39315,55 +40888,6 @@ fn aiur_fn_461( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_461], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(121); - let __v_1: G = G::from_u64(165); - let __v_2: G = G::from_u64(126); - let __v_3: G = G::from_u64(127); - let __v_4: G = G::from_u64(141); - let __v_5: G = G::from_u64(16); - let __v_6: G = G::from_u64(48); - let __v_7: G = G::from_u64(251); - let __v_8: G = G::from_u64(149); - let __v_9: G = G::from_u64(255); - let __v_10: G = G::from_u64(79); - let __v_11: G = G::from_u64(25); - let __v_12: G = G::from_u64(234); - let __v_13: G = G::from_u64(33); - let __v_14: G = G::from_u64(44); - let __v_15: G = G::from_u64(154); - let __v_16: G = G::from_u64(224); - let __v_17: G = G::from_u64(17); - let __v_18: G = G::from_u64(99); - let __v_19: G = G::from_u64(143); - let __v_20: G = G::from_u64(247); - let __v_21: G = G::from_u64(52); - let __v_22: G = G::from_u64(156); - let __v_23: G = G::from_u64(74); - let __v_24: G = G::from_u64(105); - let __v_25: G = G::from_u64(45); - let __v_26: G = G::from_u64(223); - let __v_27: G = G::from_u64(94); - let __v_28: G = G::from_u64(142); - let __v_29: G = G::from_u64(7); - let __v_30: G = G::from_u64(26); - let __v_31: G = G::from_u64(212); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_461] = [__v_32]; - record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - -const INPUT_SIZE_462: usize = 0; -const IN_462: usize = 0; -const OUT_462: usize = 1; -fn aiur_fn_462( - inp: [G; IN_462], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(230); let __v_1: G = G::from_u64(235); @@ -39397,22 +40921,23 @@ fn aiur_fn_462( let __v_29: G = G::from_u64(201); let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_462] = [__v_32]; - record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_461] = [__v_32]; + record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_463: usize = 0; -const IN_463: usize = 0; -const OUT_463: usize = 1; -fn aiur_fn_463( - inp: [G; IN_463], +const INPUT_SIZE_462: usize = 0; +const IN_462: usize = 0; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_463], ExecError> { +) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(108); let __v_1: G = G::from_u64(155); @@ -39446,9 +40971,60 @@ fn aiur_fn_463( let __v_29: G = G::from_u64(167); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(206); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_462] = [__v_32]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_463: usize = 0; +const IN_463: usize = 0; +const OUT_463: usize = 1; +fn aiur_fn_463( + inp: [G; IN_463], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_463], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(131); + let __v_1: G = G::from_u64(253); + let __v_2: G = G::from_u64(227); + let __v_3: G = G::from_u64(143); + let __v_4: G = G::from_u64(170); + let __v_5: G = G::from_u64(17); + let __v_6: G = G::from_u64(100); + let __v_7: G = G::from_u64(100); + let __v_8: G = G::from_u64(142); + let __v_9: G = G::from_u64(66); + let __v_10: G = G::from_u64(39); + let __v_11: G = G::from_u64(151); + let __v_12: G = G::from_u64(90); + let __v_13: G = G::from_u64(191); + let __v_14: G = G::from_u64(46); + let __v_15: G = G::from_u64(140); + let __v_16: G = G::from_u64(38); + let __v_17: G = G::from_u64(13); + let __v_18: G = G::from_u64(125); + let __v_19: G = G::from_u64(78); + let __v_20: G = G::from_u64(241); + let __v_21: G = G::from_u64(201); + let __v_22: G = G::from_u64(38); + let __v_23: G = G::from_u64(118); + let __v_24: G = G::from_u64(33); + let __v_25: G = G::from_u64(79); + let __v_26: G = G::from_u64(254); + let __v_27: G = G::from_u64(88); + let __v_28: G = G::from_u64(38); + let __v_29: G = G::from_u64(194); + let __v_30: G = G::from_u64(7); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_463] = [__v_32]; record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39463,41 +41039,42 @@ fn aiur_fn_464( unconstrained: bool, ) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(64); - let __v_1: G = G::from_u64(44); - let __v_2: G = G::from_u64(176); - let __v_3: G = G::from_u64(27); - let __v_4: G = G::from_u64(250); - let __v_5: G = G::from_u64(82); - let __v_6: G = G::from_u64(254); - let __v_7: G = G::from_u64(147); - let __v_8: G = G::from_u64(174); - let __v_9: G = G::from_u64(243); - let __v_10: G = G::from_u64(217); - let __v_11: G = G::from_u64(110); - let __v_12: G = G::from_u64(125); - let __v_13: G = G::from_u64(40); - let __v_14: G = G::from_u64(238); - let __v_15: G = G::from_u64(3); - let __v_16: G = G::from_u64(224); - let __v_17: G = G::from_u64(225); - let __v_18: G = G::from_u64(247); - let __v_19: G = G::from_u64(111); - let __v_20: G = G::from_u64(60); - let __v_21: G = G::from_u64(135); - let __v_22: G = G::from_u64(150); - let __v_23: G = G::from_u64(84); - let __v_24: G = G::from_u64(245); - let __v_25: G = G::from_u64(231); - let __v_26: G = G::from_u64(25); - let __v_27: G = G::from_u64(167); - let __v_28: G = G::from_u64(32); - let __v_29: G = G::from_u64(21); - let __v_30: G = G::from_u64(35); - let __v_31: G = G::from_u64(127); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(56); + let __v_1: G = G::from_u64(214); + let __v_2: G = G::from_u64(15); + let __v_3: G = G::from_u64(250); + let __v_4: G = G::from_u64(7); + let __v_5: G = G::from_u64(181); + let __v_6: G = G::from_u64(6); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(208); + let __v_9: G = G::from_u64(195); + let __v_10: G = G::from_u64(191); + let __v_11: G = G::from_u64(12); + let __v_12: G = G::from_u64(6); + let __v_13: G = G::from_u64(248); + let __v_14: G = G::from_u64(108); + let __v_15: G = G::from_u64(215); + let __v_16: G = G::from_u64(150); + let __v_17: G = G::from_u64(123); + let __v_18: G = G::from_u64(53); + let __v_19: G = G::from_u64(232); + let __v_20: G = G::from_u64(122); + let __v_21: G = G::from_u64(176); + let __v_22: G = G::from_u64(113); + let __v_23: G = G::from_u64(188); + let __v_24: G = G::from_u64(85); + let __v_25: G = G::from_u64(137); + let __v_26: G = G::from_u64(159); + let __v_27: G = G::from_u64(203); + let __v_28: G = G::from_u64(174); + let __v_29: G = G::from_u64(212); + let __v_30: G = G::from_u64(116); + let __v_31: G = G::from_u64(79); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_464] = [__v_32]; record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39512,41 +41089,42 @@ fn aiur_fn_465( unconstrained: bool, ) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(191); - let __v_1: G = G::from_u64(254); - let __v_2: G = G::from_u64(215); - let __v_3: G = G::from_u64(205); - let __v_4: G = G::from_u64(73); - let __v_5: G = G::from_u64(104); - let __v_6: G = G::from_u64(184); - let __v_7: G = G::from_u64(252); - let __v_8: G = G::from_u64(37); - let __v_9: G = G::from_u64(30); - let __v_10: G = G::from_u64(210); - let __v_11: G = G::from_u64(74); - let __v_12: G = G::from_u64(156); - let __v_13: G = G::from_u64(37); - let __v_14: G = G::from_u64(61); - let __v_15: G = G::from_u64(160); - let __v_16: G = G::from_u64(2); - let __v_17: G = G::from_u64(21); - let __v_18: G = G::from_u64(144); - let __v_19: G = G::from_u64(35); - let __v_20: G = G::from_u64(84); - let __v_21: G = G::from_u64(194); - let __v_22: G = G::from_u64(148); - let __v_23: G = G::from_u64(79); - let __v_24: G = G::from_u64(89); - let __v_25: G = G::from_u64(232); - let __v_26: G = G::from_u64(21); - let __v_27: G = G::from_u64(56); - let __v_28: G = G::from_u64(220); - let __v_29: G = G::from_u64(26); - let __v_30: G = G::from_u64(226); - let __v_31: G = G::from_u64(199); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_0: G = G::from_u64(85); + let __v_1: G = G::from_u64(104); + let __v_2: G = G::from_u64(231); + let __v_3: G = G::from_u64(153); + let __v_4: G = G::from_u64(25); + let __v_5: G = G::from_u64(141); + let __v_6: G = G::from_u64(173); + let __v_7: G = G::from_u64(159); + let __v_8: G = G::from_u64(171); + let __v_9: G = G::from_u64(14); + let __v_10: G = G::from_u64(120); + let __v_11: G = G::from_u64(75); + let __v_12: G = G::from_u64(122); + let __v_13: G = G::from_u64(76); + let __v_14: G = G::from_u64(88); + let __v_15: G = G::from_u64(17); + let __v_16: G = G::from_u64(43); + let __v_17: G = G::from_u64(252); + let __v_18: G = G::from_u64(38); + let __v_19: G = G::from_u64(136); + let __v_20: G = G::from_u64(174); + let __v_21: G = G::from_u64(206); + let __v_22: G = G::from_u64(190); + let __v_23: G = G::from_u64(60); + let __v_24: G = G::from_u64(44); + let __v_25: G = G::from_u64(101); + let __v_26: G = G::from_u64(99); + let __v_27: G = G::from_u64(48); + let __v_28: G = G::from_u64(66); + let __v_29: G = G::from_u64(16); + let __v_30: G = G::from_u64(249); + let __v_31: G = G::from_u64(86); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_465] = [__v_32]; record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39560,55 +41138,6 @@ fn aiur_fn_466( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_466], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(9); - let __v_1: G = G::from_u64(181); - let __v_2: G = G::from_u64(251); - let __v_3: G = G::from_u64(47); - let __v_4: G = G::from_u64(45); - let __v_5: G = G::from_u64(132); - let __v_6: G = G::from_u64(81); - let __v_7: G = G::from_u64(104); - let __v_8: G = G::from_u64(159); - let __v_9: G = G::from_u64(132); - let __v_10: G = G::from_u64(39); - let __v_11: G = G::from_u64(17); - let __v_12: G = G::from_u64(116); - let __v_13: G = G::from_u64(74); - let __v_14: G = G::from_u64(39); - let __v_15: G = G::from_u64(191); - let __v_16: G = G::from_u64(229); - let __v_17: G = G::from_u64(92); - let __v_18: G = G::from_u64(111); - let __v_19: G = G::from_u64(213); - let __v_20: G = G::from_u64(1); - let __v_21: G = G::from_u64(15); - let __v_22: G = G::from_u64(210); - let __v_23: G = G::from_u64(74); - let __v_24: G = G::from_u64(144); - let __v_25: G = G::from_u64(132); - let __v_26: G = G::from_u64(83); - let __v_27: G = G::from_u64(147); - let __v_28: G = G::from_u64(199); - let __v_29: G = G::from_u64(7); - let __v_30: G = G::from_u64(224); - let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_466] = [__v_32]; - record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - -const INPUT_SIZE_467: usize = 0; -const IN_467: usize = 0; -const OUT_467: usize = 1; -fn aiur_fn_467( - inp: [G; IN_467], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(188); @@ -39642,22 +41171,23 @@ fn aiur_fn_467( let __v_29: G = G::from_u64(132); let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(220); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_467] = [__v_32]; - record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_466] = [__v_32]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_468: usize = 0; -const IN_468: usize = 0; -const OUT_468: usize = 1; -fn aiur_fn_468( - inp: [G; IN_468], +const INPUT_SIZE_467: usize = 0; +const IN_467: usize = 0; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: [G; IN_467], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_468], ExecError> { +) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(38); let __v_1: G = G::from_u64(124); @@ -39691,99 +41221,107 @@ fn aiur_fn_468( let __v_29: G = G::from_u64(241); let __v_30: G = G::from_u64(73); let __v_31: G = G::from_u64(241); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_468] = [__v_32]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_467] = [__v_32]; + record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_469: usize = 1; -const IN_469: usize = 1; -const OUT_469: usize = 1; -fn aiur_fn_469( - inp: [G; IN_469], +const INPUT_SIZE_468: usize = 1; +const IN_468: usize = 1; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: [G; IN_468], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_469], ExecError> { +) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_3]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_3]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_5]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_5]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_7]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_7]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_9]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_9]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_11]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_11]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_13]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_469] = [__v_13]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39800,56 +41338,60 @@ fn aiur_fn_469( }) } -const INPUT_SIZE_470: usize = 1; -const IN_470: usize = 1; -const OUT_470: usize = 1; -fn aiur_fn_470( - inp: [G; IN_470], +const INPUT_SIZE_469: usize = 1; +const IN_469: usize = 1; +const OUT_469: usize = 1; +fn aiur_fn_469( + inp: [G; IN_469], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_470], ExecError> { +) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_470] = [__v_3]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_3]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_470] = [__v_5]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_5]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_470] = [__v_7]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_7]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_470] = [__v_7]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_7]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39860,15 +41402,15 @@ fn aiur_fn_470( }) } -const INPUT_SIZE_471: usize = 1; -const IN_471: usize = 1; -const OUT_471: usize = 3; -fn aiur_fn_471( - inp: [G; IN_471], +const INPUT_SIZE_470: usize = 1; +const IN_470: usize = 1; +const OUT_470: usize = 3; +fn aiur_fn_470( + inp: [G; IN_470], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_471], ExecError> { +) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39885,11 +41427,11 @@ fn aiur_fn_471( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -39900,9 +41442,10 @@ fn aiur_fn_471( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_471] = [__v_14, __v_15, __v_18]; - record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_470] = [__v_14, __v_15, __v_18]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39916,8 +41459,9 @@ fn aiur_fn_471( match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); - let __ret: [G; OUT_471] = [__v_18, __v_12, __v_16]; - record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_470] = [__v_18, __v_12, __v_16]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39925,9 +41469,10 @@ fn aiur_fn_471( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_471] = [__v_18, __v_19, __v_22]; - record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_470] = [__v_18, __v_19, __v_22]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39937,9 +41482,10 @@ fn aiur_fn_471( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_471] = [__v_18, __v_19, __v_22]; - record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_470] = [__v_18, __v_19, __v_22]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39951,9 +41497,10 @@ fn aiur_fn_471( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_471] = [__v_9, __v_10, __v_13]; - record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_470] = [__v_9, __v_10, __v_13]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39963,35 +41510,36 @@ fn aiur_fn_471( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_471] = [__v_5, __v_6, __v_9]; - record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_470] = [__v_5, __v_6, __v_9]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_472: usize = 2; -const IN_472: usize = 2; -const OUT_472: usize = 1; -fn aiur_fn_472( - inp: [G; IN_472], +const INPUT_SIZE_471: usize = 2; +const IN_471: usize = 2; +const OUT_471: usize = 1; +fn aiur_fn_471( + inp: [G; IN_471], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_472], 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -40001,37 +41549,38 @@ fn aiur_fn_472( let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_9: G = G::from_u64(7); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_472] = [__v_15]; - record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_471] = [__v_15]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_473: usize = 4; -const IN_473: usize = 4; -const OUT_473: usize = 2; -fn aiur_fn_473( - inp: [G; IN_473], +const INPUT_SIZE_472: usize = 4; +const IN_472: usize = 4; +const OUT_472: usize = 2; +fn aiur_fn_472( + inp: [G; IN_472], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_473], ExecError> { +) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40041,25 +41590,26 @@ fn aiur_fn_473( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_473] = [__v_7, __v_11]; - record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_472] = [__v_7, __v_11]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __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_471] = { let __args: [G; IN_471] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -40069,27 +41619,30 @@ fn aiur_fn_473( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_473] = [__v_17, __v_21]; - record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_472] = [__v_17, __v_21]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_473] = [__v_17, __v_18]; - record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_472] = [__v_17, __v_18]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_473] = [__v_14, __v_15]; - record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_472] = [__v_14, __v_15]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40098,15 +41651,15 @@ fn aiur_fn_473( }) } -const INPUT_SIZE_474: usize = 6; -const IN_474: usize = 6; -const OUT_474: usize = 2; -fn aiur_fn_474( - inp: [G; IN_474], +const INPUT_SIZE_473: usize = 6; +const IN_473: usize = 6; +const OUT_473: usize = 2; +fn aiur_fn_473( + inp: [G; IN_473], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_474], 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]; @@ -40114,43 +41667,44 @@ fn aiur_fn_474( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __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_471] = { let __args: [G; IN_471] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __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_472] = { let __args: [G; IN_472] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_474] = [__v_27, __v_28]; - record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_473] = [__v_27, __v_28]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40158,9 +41712,10 @@ fn aiur_fn_474( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_474] = [__v_14, __v_18]; - record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_473] = [__v_14, __v_18]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40170,30 +41725,31 @@ fn aiur_fn_474( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_474] = [__v_11, __v_15]; - record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_473] = [__v_11, __v_15]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_475: usize = 4; -const IN_475: usize = 4; -const OUT_475: usize = 2; -fn aiur_fn_475( - inp: [G; IN_475], +const INPUT_SIZE_474: usize = 4; +const IN_474: usize = 4; +const OUT_474: usize = 2; +fn aiur_fn_474( + inp: [G; IN_474], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_475], 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_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40203,51 +41759,55 @@ fn aiur_fn_475( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_475] = [__v_7, __v_11]; - record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_474] = [__v_7, __v_11]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_475] = [__v_8, __v_9]; - record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_474] = [__v_8, __v_9]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_475] = [__v_14, __v_15]; - record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_474] = [__v_14, __v_15]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_475] = [__v_14, __v_15]; - record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_474] = [__v_14, __v_15]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40258,26 +41818,26 @@ fn aiur_fn_475( }) } -const INPUT_SIZE_476: usize = 3; -const IN_476: usize = 3; -const OUT_476: usize = 2; -fn aiur_fn_476( - inp: [G; IN_476], +const INPUT_SIZE_475: usize = 3; +const IN_475: usize = 3; +const OUT_475: usize = 2; +fn aiur_fn_475( + inp: [G; IN_475], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_476], 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 __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -40288,9 +41848,10 @@ fn aiur_fn_476( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_476] = [__v_10, __v_14]; - record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_475] = [__v_10, __v_14]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -40299,24 +41860,25 @@ fn aiur_fn_476( let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_476] = [__v_24, __v_25]; - record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_475] = [__v_24, __v_25]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40326,15 +41888,15 @@ fn aiur_fn_476( }) } -const INPUT_SIZE_477: usize = 6; -const IN_477: usize = 6; -const OUT_477: usize = 2; -fn aiur_fn_477( - inp: [G; IN_477], +const INPUT_SIZE_476: usize = 6; +const IN_476: usize = 6; +const OUT_476: usize = 2; +fn aiur_fn_476( + inp: [G; IN_476], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_477], 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]; @@ -40343,14 +41905,14 @@ fn aiur_fn_477( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -40361,9 +41923,10 @@ fn aiur_fn_477( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_477] = [__v_14, __v_18]; - record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_476] = [__v_14, __v_18]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -40376,9 +41939,10 @@ fn aiur_fn_477( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_477] = [__v_16, __v_20]; - record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_476] = [__v_16, __v_20]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -40389,18 +41953,19 @@ fn aiur_fn_477( break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_477] = [__v_17, __v_18]; - record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_476] = [__v_17, __v_18]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40415,15 +41980,15 @@ fn aiur_fn_477( }) } -const INPUT_SIZE_478: usize = 9; -const IN_478: usize = 9; -const OUT_478: usize = 2; -fn aiur_fn_478( - inp: [G; IN_478], +const INPUT_SIZE_477: usize = 9; +const IN_477: usize = 9; +const OUT_477: usize = 2; +fn aiur_fn_477( + inp: [G; IN_477], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_478], 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]; @@ -40443,36 +42008,37 @@ fn aiur_fn_478( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_12, __v_16]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_477] = [__v_12, __v_16]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; @@ -40490,25 +42056,25 @@ fn aiur_fn_478( let __v_35: G = G::from_u64(2); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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_458] = { let __args: [G; IN_458] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -40517,12 +42083,12 @@ fn aiur_fn_478( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -40534,43 +42100,44 @@ fn aiur_fn_478( let __v_48: G = G::from_u64(2); let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_54: G = G::from_u64(3); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_57: G = G::from_u64(3); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; - let __ret: [G; OUT_478] = [__v_63, __v_64]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_477] = [__v_63, __v_64]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_479: usize = 3; -const IN_479: usize = 3; -const OUT_479: usize = 2; -fn aiur_fn_479( - inp: [G; IN_479], +const INPUT_SIZE_478: usize = 3; +const IN_478: usize = 3; +const OUT_478: usize = 2; +fn aiur_fn_478( + inp: [G; IN_478], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_479], 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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40580,17 +42147,18 @@ fn aiur_fn_479( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_6, __v_10]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_478] = [__v_6, __v_10]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -40610,7 +42178,7 @@ fn aiur_fn_479( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -40618,17 +42186,19 @@ fn aiur_fn_479( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_19, __v_23]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_478] = [__v_19, __v_23]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_479] = [__v_19, __v_20]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_478] = [__v_19, __v_20]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40638,9 +42208,10 @@ fn aiur_fn_479( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_18, __v_22]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_478] = [__v_18, __v_22]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40650,9 +42221,10 @@ fn aiur_fn_479( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_18, __v_22]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_478] = [__v_18, __v_22]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40662,9 +42234,10 @@ fn aiur_fn_479( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_14, __v_18]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_478] = [__v_14, __v_18]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40674,9 +42247,10 @@ fn aiur_fn_479( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_14, __v_18]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_478] = [__v_14, __v_18]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40685,15 +42259,15 @@ fn aiur_fn_479( }) } -const INPUT_SIZE_480: usize = 4; -const IN_480: usize = 4; -const OUT_480: usize = 2; -fn aiur_fn_480( - inp: [G; IN_480], +const INPUT_SIZE_479: usize = 4; +const IN_479: usize = 4; +const OUT_479: usize = 2; +fn aiur_fn_479( + inp: [G; IN_479], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_480], 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]; @@ -40702,56 +42276,56 @@ fn aiur_fn_480( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_19: G = G::from_u64(2); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_24: G = G::from_u64(0); - let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_33: G = G::from_u64(3); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_36: G = G::from_u64(2); let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40761,52 +42335,54 @@ fn aiur_fn_480( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_480] = [__v_52, __v_56]; - record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_479] = [__v_52, __v_56]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); - let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_59: G = G::from_u64(0); - let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_61: G = G::from_u64(3); let __v_62: G = G::from_u64(0); - let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_64: G = G::from_u64(3); let __v_65: G = G::from_u64(0); - let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_480] = [__v_69, __v_70]; - record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_69, __v_70]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_481: usize = 6; -const IN_481: usize = 6; -const OUT_481: usize = 2; -fn aiur_fn_481( - inp: [G; IN_481], +const INPUT_SIZE_480: usize = 6; +const IN_480: usize = 6; +const OUT_480: usize = 2; +fn aiur_fn_480( + inp: [G; IN_480], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_481], 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]; @@ -40816,12 +42392,12 @@ fn aiur_fn_481( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -40830,20 +42406,20 @@ fn aiur_fn_481( let __v_6: G = __mc_out___mc_0[0]; let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40853,50 +42429,52 @@ fn aiur_fn_481( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_481] = [__v_20, __v_24]; - record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_480] = [__v_20, __v_24]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_28: G = G::from_u64(3); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_481] = [__v_36, __v_37]; - record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_480] = [__v_36, __v_37]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_482: usize = 2; -const IN_482: usize = 2; -const OUT_482: usize = 1; -fn aiur_fn_482( - inp: [G; IN_482], +const INPUT_SIZE_481: usize = 2; +const IN_481: usize = 2; +const OUT_481: usize = 1; +fn aiur_fn_481( + inp: [G; IN_481], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_482], 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]; @@ -40904,8 +42482,9 @@ fn aiur_fn_482( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_482] = [__v_3]; - record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_481] = [__v_3]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40913,14 +42492,16 @@ fn aiur_fn_482( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_482] = [__v_4]; - record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_481] = [__v_4]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_482] = [__v_4]; - record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_481] = [__v_4]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40932,33 +42513,54 @@ fn aiur_fn_482( }) } -const INPUT_SIZE_483: usize = 2; -const IN_483: usize = 2; -const OUT_483: usize = 1; -fn aiur_fn_483( - inp: [G; IN_483], +const INPUT_SIZE_482: usize = 2; +const IN_482: usize = 2; +const OUT_482: usize = 1; +fn aiur_fn_482( + inp: [G; IN_482], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_483], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_483] = [__v_1]; - record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_482] = [__v_1]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_483] = [__v_0]; - record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_482] = [__v_0]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } +const INPUT_SIZE_483: usize = 0; +const IN_483: usize = 0; +const OUT_483: usize = 2; +fn aiur_fn_483( + inp: [G; IN_483], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_483], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_483] = [__v_0, __v_1]; + record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }) +} + const INPUT_SIZE_484: usize = 0; const IN_484: usize = 0; const OUT_484: usize = 2; @@ -40969,10 +42571,11 @@ fn aiur_fn_484( unconstrained: bool, ) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(0); + let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_484] = [__v_0, __v_1]; record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40987,16 +42590,17 @@ fn aiur_fn_485( unconstrained: bool, ) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(1); + let __v_0: G = G::from_u64(2); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_0, __v_1]; record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_486: usize = 0; -const IN_486: usize = 0; +const INPUT_SIZE_486: usize = 4; +const IN_486: usize = 4; const OUT_486: usize = 2; fn aiur_fn_486( inp: [G; IN_486], @@ -41004,24 +42608,6 @@ fn aiur_fn_486( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_486], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(2); - let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_486] = [__v_0, __v_1]; - record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - -const INPUT_SIZE_487: usize = 4; -const IN_487: usize = 4; -const OUT_487: usize = 2; -fn aiur_fn_487( - inp: [G; IN_487], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> 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]; @@ -41030,46 +42616,49 @@ fn aiur_fn_487( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_487] = [__v_2, __v_4]; - record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_486] = [__v_2, __v_4]; + record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_487] = [__v_0, __v_1]; - record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_486] = [__v_0, __v_1]; + record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_488: usize = 1; -const IN_488: usize = 1; -const OUT_488: usize = 2; -fn aiur_fn_488( - inp: [G; IN_488], +const INPUT_SIZE_487: usize = 1; +const IN_487: usize = 1; +const OUT_487: usize = 2; +fn aiur_fn_487( + inp: [G; IN_487], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_488], ExecError> { +) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_488] = [__v_0, __v_1]; - record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_487] = [__v_0, __v_1]; + record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_488: usize = 2; +const IN_488: usize = 2; +const OUT_488: usize = 1; +fn aiur_fn_488( + inp: [G; IN_488], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_489], 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]; @@ -41139,51 +42728,52 @@ fn aiur_fn_489( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_80]; - record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_488] = [__v_80]; + record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_490: usize = 8; -const IN_490: usize = 8; -const OUT_490: usize = 1; -fn aiur_fn_490( - inp: [G; IN_490], +const INPUT_SIZE_489: usize = 8; +const IN_489: usize = 8; +const OUT_489: usize = 1; +fn aiur_fn_489( + inp: [G; IN_489], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_490], ExecError> { +) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41211,23 +42801,24 @@ fn aiur_fn_490( 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_482] = { let __args: [G; IN_482] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_26]; - record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_489] = [__v_26]; + record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -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_490: usize = 2; +const IN_490: usize = 2; +const OUT_490: usize = 1; +fn aiur_fn_490( + inp: [G; IN_490], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_491], 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]; @@ -41239,8 +42830,9 @@ fn aiur_fn_491( match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_491] = [__v_6]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_490] = [__v_6]; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -41250,15 +42842,17 @@ fn aiur_fn_491( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); - let __ret: [G; OUT_491] = [__v_8]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_490] = [__v_8]; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_491] = [__v_7]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_490] = [__v_7]; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41270,15 +42864,15 @@ fn aiur_fn_491( }) } -const INPUT_SIZE_492: usize = 3; -const IN_492: usize = 3; -const OUT_492: usize = 2; -fn aiur_fn_492( - inp: [G; IN_492], +const INPUT_SIZE_491: usize = 3; +const IN_491: usize = 3; +const OUT_491: usize = 2; +fn aiur_fn_491( + inp: [G; IN_491], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_492], ExecError> { +) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41287,37 +42881,40 @@ fn aiur_fn_492( let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_492] = [__v_4, __v_5]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_4, __v_5]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_492] = [__v_7, __v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_7, __v_8]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_492] = [__v_6, __v_7]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_6, __v_7]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41325,19 +42922,21 @@ fn aiur_fn_492( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_492] = [__v_6, __v_7]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_6, __v_7]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_492] = [__v_6, __v_7]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_6, __v_7]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41348,15 +42947,15 @@ fn aiur_fn_492( }) } -const INPUT_SIZE_493: usize = 2; -const IN_493: usize = 2; -const OUT_493: usize = 1; -fn aiur_fn_493( - inp: [G; IN_493], +const INPUT_SIZE_492: usize = 2; +const IN_492: usize = 2; +const OUT_492: usize = 1; +fn aiur_fn_492( + inp: [G; IN_492], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_493], 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]; @@ -41373,14 +42972,16 @@ fn aiur_fn_493( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41393,21 +42994,24 @@ fn aiur_fn_493( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41420,31 +43024,35 @@ fn aiur_fn_493( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_10]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_10]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41457,37 +43065,42 @@ fn aiur_fn_493( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_10]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_10]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41502,16 +43115,18 @@ fn aiur_fn_493( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41523,15 +43138,15 @@ fn aiur_fn_493( }) } -const INPUT_SIZE_494: usize = 2; -const IN_494: usize = 2; -const OUT_494: usize = 1; -fn aiur_fn_494( - inp: [G; IN_494], +const INPUT_SIZE_493: usize = 2; +const IN_493: usize = 2; +const OUT_493: usize = 1; +fn aiur_fn_493( + inp: [G; IN_493], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_494], 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]; @@ -41548,14 +43163,16 @@ fn aiur_fn_494( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_494] = [__v_8]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_494] = [__v_8]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41568,19 +43185,21 @@ fn aiur_fn_494( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_494] = [__v_8]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_494] = [__v_10]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_10]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41595,15 +43214,15 @@ fn aiur_fn_494( }) } -const INPUT_SIZE_495: usize = 4; -const IN_495: usize = 4; -const OUT_495: usize = 1; -fn aiur_fn_495( - inp: [G; IN_495], +const INPUT_SIZE_494: usize = 4; +const IN_494: usize = 4; +const OUT_494: usize = 1; +fn aiur_fn_494( + inp: [G; IN_494], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_495], 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]; @@ -41613,16 +43232,18 @@ fn aiur_fn_495( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_495] = [__v_4]; - record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_4]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_495] = [__v_4]; - record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_4]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41634,15 +43255,17 @@ fn aiur_fn_495( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_495] = [__v_4]; - record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_4]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_495] = [__v_4]; - record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_4]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41657,15 +43280,15 @@ fn aiur_fn_495( }) } -const INPUT_SIZE_496: usize = 2; -const IN_496: usize = 2; -const OUT_496: usize = 1; -fn aiur_fn_496( - inp: [G; IN_496], +const INPUT_SIZE_495: usize = 2; +const IN_495: usize = 2; +const OUT_495: usize = 1; +fn aiur_fn_495( + inp: [G; IN_495], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_496], 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]; @@ -41673,38 +43296,40 @@ fn aiur_fn_496( let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_496] = [__v_7]; - record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_495] = [__v_7]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_496] = [__v_6]; - record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_495] = [__v_6]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_497: usize = 2; -const IN_497: usize = 2; -const OUT_497: usize = 1; -fn aiur_fn_497( - inp: [G; IN_497], +const INPUT_SIZE_496: usize = 2; +const IN_496: usize = 2; +const OUT_496: usize = 1; +fn aiur_fn_496( + inp: [G; IN_496], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_497], 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]; @@ -41722,8 +43347,9 @@ fn aiur_fn_497( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_497] = [__v_12]; - record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_496] = [__v_12]; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -41740,14 +43366,15 @@ fn aiur_fn_497( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_497] = [__v_24]; - record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_496] = [__v_24]; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41762,15 +43389,15 @@ fn aiur_fn_497( }) } -const INPUT_SIZE_498: usize = 16; -const IN_498: usize = 16; -const OUT_498: usize = 1; -fn aiur_fn_498( - inp: [G; IN_498], +const INPUT_SIZE_497: usize = 16; +const IN_497: usize = 16; +const OUT_497: usize = 1; +fn aiur_fn_497( + inp: [G; IN_497], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_498], 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]; @@ -41788,51 +43415,52 @@ fn aiur_fn_498( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_498] = [__v_30]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_497] = [__v_30]; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_499: usize = 2; -const IN_499: usize = 2; -const OUT_499: usize = 1; -fn aiur_fn_499( - inp: [G; IN_499], +const INPUT_SIZE_498: usize = 2; +const IN_498: usize = 2; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: [G; IN_498], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_499], 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]; @@ -41849,14 +43477,16 @@ fn aiur_fn_499( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_499] = [__v_8]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_498] = [__v_8]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_499] = [__v_8]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_498] = [__v_8]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41869,19 +43499,21 @@ fn aiur_fn_499( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_499] = [__v_8]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_498] = [__v_8]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_499] = [__v_10]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_498] = [__v_10]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41896,15 +43528,15 @@ fn aiur_fn_499( }) } -const INPUT_SIZE_500: usize = 3; -const IN_500: usize = 3; -const OUT_500: usize = 2; -fn aiur_fn_500( - inp: [G; IN_500], +const INPUT_SIZE_499: usize = 3; +const IN_499: usize = 3; +const OUT_499: usize = 2; +fn aiur_fn_499( + inp: [G; IN_499], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_500], 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]; @@ -41912,11 +43544,12 @@ fn aiur_fn_500( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_4, __v_5]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_4, __v_5]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41930,26 +43563,27 @@ fn aiur_fn_500( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_12, __v_13]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_12, __v_13]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_501: usize = 9; -const IN_501: usize = 9; -const OUT_501: usize = 2; -fn aiur_fn_501( - inp: [G; IN_501], +const INPUT_SIZE_500: usize = 9; +const IN_500: usize = 9; +const OUT_500: usize = 2; +fn aiur_fn_500( + inp: [G; IN_500], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_501], 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]; @@ -41964,21 +43598,23 @@ fn aiur_fn_501( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_10, __v_11]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_10, __v_11]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41986,29 +43622,32 @@ fn aiur_fn_501( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_10, __v_11]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_10, __v_11]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42016,43 +43655,47 @@ fn aiur_fn_501( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_14, __v_15]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_14, __v_15]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42060,49 +43703,54 @@ fn aiur_fn_501( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_13, __v_14]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_13, __v_14]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42110,57 +43758,63 @@ fn aiur_fn_501( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_13, __v_14]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_13, __v_14]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42168,65 +43822,72 @@ fn aiur_fn_501( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_13, __v_14]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_13, __v_14]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42234,79 +43895,87 @@ fn aiur_fn_501( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_17, __v_18]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_17, __v_18]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42314,29 +43983,32 @@ fn aiur_fn_501( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_10, __v_11]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_10, __v_11]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42344,33 +44016,35 @@ fn aiur_fn_501( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_18, __v_19]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_18, __v_19]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_9, __v_10]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_9, __v_10]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42382,15 +44056,15 @@ fn aiur_fn_501( }) } -const INPUT_SIZE_502: usize = 7; -const IN_502: usize = 7; -const OUT_502: usize = 2; -fn aiur_fn_502( - inp: [G; IN_502], +const INPUT_SIZE_501: usize = 7; +const IN_501: usize = 7; +const OUT_501: usize = 2; +fn aiur_fn_501( + inp: [G; IN_501], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_502], 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]; @@ -42403,19 +44077,20 @@ fn aiur_fn_502( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_502] = [__v_12, __v_13]; - record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_12, __v_13]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42424,15 +44099,15 @@ fn aiur_fn_502( }) } -const INPUT_SIZE_503: usize = 3; -const IN_503: usize = 3; -const OUT_503: usize = 2; -fn aiur_fn_503( - inp: [G; IN_503], +const INPUT_SIZE_502: usize = 3; +const IN_502: usize = 3; +const OUT_502: usize = 2; +fn aiur_fn_502( + inp: [G; IN_502], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_503], 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]; @@ -42453,19 +44128,21 @@ fn aiur_fn_503( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_503] = [__v_13, __v_14]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_13, __v_14]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_503] = [__v_13, __v_14]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_13, __v_14]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42479,25 +44156,27 @@ fn aiur_fn_503( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_503] = [__v_13, __v_14]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_13, __v_14]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_503] = [__v_17, __v_18]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_17, __v_18]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42512,15 +44191,15 @@ fn aiur_fn_503( }) } -const INPUT_SIZE_504: usize = 12; -const IN_504: usize = 12; -const OUT_504: usize = 1; -fn aiur_fn_504( - inp: [G; IN_504], +const INPUT_SIZE_503: usize = 12; +const IN_503: usize = 12; +const OUT_503: usize = 1; +fn aiur_fn_503( + inp: [G; IN_503], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_504], 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]; @@ -42537,50 +44216,58 @@ fn aiur_fn_504( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); - let __ret: [G; OUT_504] = [__v_12]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_12]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42590,15 +44277,15 @@ fn aiur_fn_504( }) } -const INPUT_SIZE_505: usize = 25; -const IN_505: usize = 25; -const OUT_505: usize = 2; -fn aiur_fn_505( - inp: [G; IN_505], +const INPUT_SIZE_504: usize = 25; +const IN_504: usize = 25; +const OUT_504: usize = 2; +fn aiur_fn_504( + inp: [G; IN_504], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_505], 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]; @@ -42625,42 +44312,44 @@ fn aiur_fn_505( let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_28, __v_29]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_28, __v_29]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_28, __v_29]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_28, __v_29]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_506: usize = 25; -const IN_506: usize = 25; -const OUT_506: usize = 2; -fn aiur_fn_506( - inp: [G; IN_506], +const INPUT_SIZE_505: usize = 25; +const IN_505: usize = 25; +const OUT_505: usize = 2; +fn aiur_fn_505( + inp: [G; IN_505], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_506], 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]; @@ -42691,33 +44380,35 @@ fn aiur_fn_506( 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_34, __v_35]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_34, __v_35]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_25, __v_26]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_25, __v_26]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42725,75 +44416,78 @@ fn aiur_fn_506( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_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_507] = { let __args: [G; IN_507] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_51, __v_52]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_51, __v_52]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_46, __v_47]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_46, __v_47]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_25, __v_26]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_25, __v_26]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42801,98 +44495,101 @@ fn aiur_fn_506( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_59, __v_60]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_59, __v_60]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_25, __v_26]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_25, __v_26]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_25, __v_26]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_25, __v_26]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_507: usize = 7; -const IN_507: usize = 7; -const OUT_507: usize = 2; -fn aiur_fn_507( - inp: [G; IN_507], +const INPUT_SIZE_506: usize = 7; +const IN_506: usize = 7; +const OUT_506: usize = 2; +fn aiur_fn_506( + inp: [G; IN_506], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_507], ExecError> { +) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42904,11 +44601,12 @@ fn aiur_fn_507( let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_507] = [__v_8, __v_9]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_8, __v_9]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42942,34 +44640,35 @@ fn aiur_fn_507( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __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_507] = { let __args: [G; IN_507] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __ret: [G; OUT_507] = [__v_40, __v_41]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_40, __v_41]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_508: usize = 25; -const IN_508: usize = 25; -const OUT_508: usize = 2; -fn aiur_fn_508( - inp: [G; IN_508], +const INPUT_SIZE_507: usize = 25; +const IN_507: usize = 25; +const OUT_507: usize = 2; +fn aiur_fn_507( + inp: [G; IN_507], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_508], ExecError> { +) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43000,88 +44699,91 @@ fn aiur_fn_508( 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_508] = [__v_45, __v_46]; - record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_45, __v_46]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_508] = [__v_28, __v_29]; - record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_28, __v_29]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_508] = [__v_28, __v_29]; - record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_28, __v_29]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_509: usize = 3; -const IN_509: usize = 3; -const OUT_509: usize = 1; -fn aiur_fn_509( - inp: [G; IN_509], +const INPUT_SIZE_508: usize = 3; +const IN_508: usize = 3; +const OUT_508: usize = 1; +fn aiur_fn_508( + inp: [G; IN_508], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_509], ExecError> { +) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43108,39 +44810,40 @@ fn aiur_fn_509( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; 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_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_509] = [__v_34]; - record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_508] = [__v_34]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_510: usize = 2; -const IN_510: usize = 2; -const OUT_510: usize = 12; -fn aiur_fn_510( - inp: [G; IN_510], +const INPUT_SIZE_509: usize = 2; +const IN_509: usize = 2; +const OUT_509: usize = 12; +fn aiur_fn_509( + inp: [G; IN_509], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_510], ExecError> { +) -> Result<[G; OUT_509], 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_720] = { let __args: [G; IN_720] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -43157,25 +44860,26 @@ fn aiur_fn_510( let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; - let __ret: [G; OUT_510] = [__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[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_509] = [__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[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_511: usize = 2; -const IN_511: usize = 2; -const OUT_511: usize = 1; -fn aiur_fn_511( - inp: [G; IN_511], +const INPUT_SIZE_510: usize = 2; +const IN_510: usize = 2; +const OUT_510: usize = 1; +fn aiur_fn_510( + inp: [G; IN_510], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_511], ExecError> { +) -> Result<[G; OUT_510], 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_510] = { let __args: [G; IN_510] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -43190,53 +44894,56 @@ fn aiur_fn_511( let __v_13: G = __r_arr[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_511] = [__v_7]; - record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_510] = [__v_7]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_511] = [__v_14]; - record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_510] = [__v_14]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_512: usize = 3; -const IN_512: usize = 3; -const OUT_512: usize = 1; -fn aiur_fn_512( - inp: [G; IN_512], +const INPUT_SIZE_511: usize = 3; +const IN_511: usize = 3; +const OUT_511: usize = 1; +fn aiur_fn_511( + inp: [G; IN_511], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_512], ExecError> { +) -> Result<[G; OUT_511], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_512] = [__v_5]; - record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_511] = [__v_5]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_513: usize = 5; -const IN_513: usize = 5; -const OUT_513: usize = 1; -fn aiur_fn_513( - inp: [G; IN_513], +const INPUT_SIZE_512: usize = 5; +const IN_512: usize = 5; +const OUT_512: usize = 1; +fn aiur_fn_512( + inp: [G; IN_512], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_513], ExecError> { +) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43251,24 +44958,26 @@ fn aiur_fn_513( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_10]; - record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_512] = [__v_10]; + record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __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_513] = { let __args: [G; IN_513] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_513] = [__v_14]; - record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_512] = [__v_14]; + record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43278,15 +44987,15 @@ fn aiur_fn_513( }) } -const INPUT_SIZE_514: usize = 5; -const IN_514: usize = 5; -const OUT_514: usize = 2; -fn aiur_fn_514( - inp: [G; IN_514], +const INPUT_SIZE_513: usize = 5; +const IN_513: usize = 5; +const OUT_513: usize = 2; +fn aiur_fn_513( + inp: [G; IN_513], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_514], ExecError> { +) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43301,37 +45010,40 @@ fn aiur_fn_514( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_514] = [__v_10, __v_11]; - record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_513] = [__v_10, __v_11]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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_514] = [__v_16, __v_10]; - record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_513] = [__v_16, __v_10]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_514] = [__v_16, __v_9]; - record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_513] = [__v_16, __v_9]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43343,15 +45055,15 @@ fn aiur_fn_514( }) } -const INPUT_SIZE_515: usize = 5; -const IN_515: usize = 5; -const OUT_515: usize = 1; -fn aiur_fn_515( - inp: [G; IN_515], +const INPUT_SIZE_514: usize = 5; +const IN_514: usize = 5; +const OUT_514: usize = 1; +fn aiur_fn_514( + inp: [G; IN_514], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_515], ExecError> { +) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43363,38 +45075,40 @@ fn aiur_fn_515( 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_515] = [__v_8]; - record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_514] = [__v_8]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_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_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_515] = [__v_12]; - record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_514] = [__v_12]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_516: usize = 3; -const IN_516: usize = 3; -const OUT_516: usize = 1; -fn aiur_fn_516( - inp: [G; IN_516], +const INPUT_SIZE_515: usize = 3; +const IN_515: usize = 3; +const OUT_515: usize = 1; +fn aiur_fn_515( + inp: [G; IN_515], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_516], ExecError> { +) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43402,29 +45116,30 @@ fn aiur_fn_516( let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_516] = [__v_11]; - record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_515] = [__v_11]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_517: usize = 4; -const IN_517: usize = 4; -const OUT_517: usize = 1; -fn aiur_fn_517( - inp: [G; IN_517], +const INPUT_SIZE_516: usize = 4; +const IN_516: usize = 4; +const OUT_516: usize = 1; +fn aiur_fn_516( + inp: [G; IN_516], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_517], ExecError> { +) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43432,30 +45147,33 @@ fn aiur_fn_517( let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_517] = [__v_0]; - record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_516] = [__v_0]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_517] = [__v_0]; - record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_516] = [__v_0]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_517] = [__v_9]; - record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_516] = [__v_9]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43464,15 +45182,15 @@ fn aiur_fn_517( }) } -const INPUT_SIZE_518: usize = 3; -const IN_518: usize = 3; -const OUT_518: usize = 1; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_517: usize = 3; +const IN_517: usize = 3; +const OUT_517: usize = 1; +fn aiur_fn_517( + inp: [G; IN_517], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_518], ExecError> { +) -> Result<[G; OUT_517], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43485,20 +45203,22 @@ fn aiur_fn_518( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_8]; - record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_517] = [__v_8]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_518] = [__v_8]; - record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_517] = [__v_8]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43508,62 +45228,65 @@ fn aiur_fn_518( }) } -const INPUT_SIZE_519: usize = 3; -const IN_519: usize = 3; -const OUT_519: usize = 1; -fn aiur_fn_519( - inp: [G; IN_519], +const INPUT_SIZE_518: usize = 3; +const IN_518: usize = 3; +const OUT_518: usize = 1; +fn aiur_fn_518( + inp: [G; IN_518], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_519], ExecError> { +) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(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_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_6]; - record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_518] = [__v_6]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_8]; - record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_518] = [__v_8]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_519] = [__v_5]; - record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_518] = [__v_5]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_520: usize = 3; -const IN_520: usize = 3; -const OUT_520: usize = 1; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_519: usize = 3; +const IN_519: usize = 3; +const OUT_519: usize = 1; +fn aiur_fn_519( + inp: [G; IN_519], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_520], ExecError> { +) -> Result<[G; OUT_519], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43576,18 +45299,20 @@ fn aiur_fn_520( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_8]; - record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_519] = [__v_8]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_520] = [__v_7]; - record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_519] = [__v_7]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43597,15 +45322,15 @@ fn aiur_fn_520( }) } -const INPUT_SIZE_521: usize = 4; -const IN_521: usize = 4; -const OUT_521: usize = 1; -fn aiur_fn_521( - inp: [G; IN_521], +const INPUT_SIZE_520: usize = 4; +const IN_520: usize = 4; +const OUT_520: usize = 1; +fn aiur_fn_520( + inp: [G; IN_520], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_521], ExecError> { +) -> Result<[G; OUT_520], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43620,14 +45345,15 @@ fn aiur_fn_521( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_11]; - record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_520] = [__v_11]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -43640,7 +45366,7 @@ fn aiur_fn_521( 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_510] = { let __args: [G; IN_510] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -43653,24 +45379,26 @@ fn aiur_fn_521( 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_505] = { let __args: [G; IN_505] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_34]; - record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_520] = [__v_34]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_35]; - record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_520] = [__v_35]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43682,15 +45410,15 @@ fn aiur_fn_521( }) } -const INPUT_SIZE_522: usize = 3; -const IN_522: usize = 3; -const OUT_522: usize = 1; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_521: usize = 3; +const IN_521: usize = 3; +const OUT_521: usize = 1; +fn aiur_fn_521( + inp: [G; IN_521], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_522], ExecError> { +) -> Result<[G; OUT_521], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43703,21 +45431,23 @@ fn aiur_fn_522( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_8]; - record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_521] = [__v_8]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_522] = [__v_11]; - record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_521] = [__v_11]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43727,15 +45457,15 @@ fn aiur_fn_522( }) } -const INPUT_SIZE_523: usize = 5; -const IN_523: usize = 5; -const OUT_523: usize = 1; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_522: usize = 5; +const IN_522: usize = 5; +const OUT_522: usize = 1; +fn aiur_fn_522( + inp: [G; IN_522], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_523], ExecError> { +) -> Result<[G; OUT_522], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43751,14 +45481,15 @@ fn aiur_fn_523( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_523] = [__v_12]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_522] = [__v_12]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -43771,7 +45502,7 @@ fn aiur_fn_523( 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_510] = { let __args: [G; IN_510] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -43784,17 +45515,18 @@ fn aiur_fn_523( 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_505] = { let __args: [G; IN_505] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __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_711] = { let __args: [G; IN_711] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __ret: [G; OUT_523] = [__v_35]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_522] = [__v_35]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43802,13 +45534,14 @@ fn aiur_fn_523( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_523] = [__v_41]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_522] = [__v_41]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43820,15 +45553,15 @@ fn aiur_fn_523( }) } -const INPUT_SIZE_524: usize = 2; -const IN_524: usize = 2; -const OUT_524: usize = 1; -fn aiur_fn_524( - inp: [G; IN_524], +const INPUT_SIZE_523: usize = 2; +const IN_523: usize = 2; +const OUT_523: usize = 1; +fn aiur_fn_523( + inp: [G; IN_523], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_524], 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]; @@ -43845,14 +45578,16 @@ fn aiur_fn_524( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_524] = [__v_8]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_8]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_524] = [__v_8]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_8]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43865,25 +45600,28 @@ fn aiur_fn_524( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_524] = [__v_8]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_8]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_524] = [__v_9]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_9]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_524] = [__v_9]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_9]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43900,15 +45638,15 @@ fn aiur_fn_524( }) } -const INPUT_SIZE_525: usize = 1; -const IN_525: usize = 1; -const OUT_525: usize = 1; -fn aiur_fn_525( - inp: [G; IN_525], +const INPUT_SIZE_524: usize = 1; +const IN_524: usize = 1; +const OUT_524: usize = 1; +fn aiur_fn_524( + inp: [G; IN_524], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_525], ExecError> { +) -> Result<[G; OUT_524], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -43919,18 +45657,20 @@ fn aiur_fn_525( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_6]; - record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_524] = [__v_6]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_525] = [__v_5]; - record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_5]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43940,15 +45680,15 @@ fn aiur_fn_525( }) } -const INPUT_SIZE_526: usize = 1; -const IN_526: usize = 1; -const OUT_526: usize = 1; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_525: usize = 1; +const IN_525: usize = 1; +const OUT_525: usize = 1; +fn aiur_fn_525( + inp: [G; IN_525], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_526], ExecError> { +) -> Result<[G; OUT_525], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -43958,25 +45698,28 @@ fn aiur_fn_526( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_526] = [__v_4]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_525] = [__v_4]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_526] = [__v_5]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_525] = [__v_5]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_526] = [__v_5]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_525] = [__v_5]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43988,15 +45731,15 @@ fn aiur_fn_526( }) } -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_526: usize = 2; +const IN_526: usize = 2; +const OUT_526: usize = 1; +fn aiur_fn_526( + inp: [G; IN_526], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_527], 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]; @@ -44052,27 +45795,30 @@ fn aiur_fn_527( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_527] = [__v_51]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_526] = [__v_51]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_527] = { let __args: [G; IN_527] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_527] = [__v_53]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_526] = [__v_53]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_527] = [__v_51]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_526] = [__v_51]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44084,15 +45830,15 @@ 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_527: usize = 2; +const IN_527: usize = 2; +const OUT_527: usize = 1; +fn aiur_fn_527( + inp: [G; IN_527], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_528], 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]; @@ -44147,8 +45893,9 @@ fn aiur_fn_528( match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_528] = [__v_49]; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_49]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -44174,15 +45921,17 @@ fn aiur_fn_528( match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); - let __ret: [G; OUT_528] = [__v_50]; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_50]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_528] = [__v_50]; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_50]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44194,15 +45943,15 @@ fn aiur_fn_528( }) } -const INPUT_SIZE_529: usize = 1; -const IN_529: usize = 1; -const OUT_529: usize = 0; -fn aiur_fn_529( - inp: [G; IN_529], +const INPUT_SIZE_528: usize = 1; +const IN_528: usize = 1; +const OUT_528: usize = 0; +fn aiur_fn_528( + inp: [G; IN_528], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_529], ExecError> { +) -> Result<[G; OUT_528], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; @@ -44259,57 +46008,60 @@ fn aiur_fn_529( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __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_718] = { let __args: [G; IN_718] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_59.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_529] = []; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = []; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_50, __v_60, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_50, __v_60, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = G::from_u64(1); if (__v_62 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_64, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_64, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); if (__v_65 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } - let __ret: [G; OUT_529] = []; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = []; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_529] = []; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = []; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44318,15 +46070,15 @@ fn aiur_fn_529( }) } -const INPUT_SIZE_530: usize = 12; -const IN_530: usize = 12; -const OUT_530: usize = 1; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_529: usize = 12; +const IN_529: usize = 12; +const OUT_529: usize = 1; +fn aiur_fn_529( + inp: [G; IN_529], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_530], 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]; @@ -44342,56 +46094,65 @@ fn aiur_fn_530( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_530] = [__v_3]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_3]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_530] = [__v_12]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_12]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_530] = [__v_12]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_12]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_530] = [__v_12]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_12]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_530] = [__v_4]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_4]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_530] = [__v_12]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_12]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_530] = [__v_6]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_6]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_530] = [__v_8]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_8]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_530] = [__v_9]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_9]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44401,15 +46162,15 @@ fn aiur_fn_530( }) } -const INPUT_SIZE_531: usize = 1; -const IN_531: usize = 1; -const OUT_531: usize = 1; -fn aiur_fn_531( - inp: [G; IN_531], +const INPUT_SIZE_530: usize = 1; +const IN_530: usize = 1; +const OUT_530: usize = 1; +fn aiur_fn_530( + inp: [G; IN_530], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_531], ExecError> { +) -> Result<[G; OUT_530], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -44420,14 +46181,16 @@ fn aiur_fn_531( match __v_1.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_531] = [__v_5]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_5]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_531] = [__v_5]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_5]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -44447,67 +46210,74 @@ fn aiur_fn_531( 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_530] = { let __args: [G; IN_530] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_531] = [__v_20]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_20]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_531] = [__v_7]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_7]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_531] = [__v_7]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_7]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_531] = [__v_7]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_7]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __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_531] = [__v_9]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_9]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_531] = [__v_5]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_5]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_531] = [__v_5]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_5]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44517,48 +46287,50 @@ fn aiur_fn_531( }) } -const INPUT_SIZE_532: usize = 2; -const IN_532: usize = 2; -const OUT_532: usize = 0; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_531: usize = 2; +const IN_531: usize = 2; +const OUT_531: usize = 0; +fn aiur_fn_531( + inp: [G; IN_531], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_532], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_532] = []; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = []; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __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_532] = []; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = []; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_533: usize = 2; -const IN_533: usize = 2; -const OUT_533: usize = 0; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_532: usize = 2; +const IN_532: usize = 2; +const OUT_532: usize = 0; +fn aiur_fn_532( + inp: [G; IN_532], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_533], 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]; @@ -44568,28 +46340,32 @@ fn aiur_fn_533( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_533] = []; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = []; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_533] = []; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_532] = []; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_533] = []; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_532] = []; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_533] = []; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_532] = []; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -44598,8 +46374,9 @@ fn aiur_fn_533( 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_533] = []; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = []; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44609,15 +46386,15 @@ fn aiur_fn_533( }) } -const INPUT_SIZE_534: usize = 2; -const IN_534: usize = 2; -const OUT_534: usize = 0; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_533: usize = 2; +const IN_533: usize = 2; +const OUT_533: usize = 0; +fn aiur_fn_533( + inp: [G; IN_533], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_534], 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]; @@ -44627,15 +46404,17 @@ fn aiur_fn_534( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_533] = []; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_533] = []; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44645,15 +46424,15 @@ fn aiur_fn_534( }) } -const INPUT_SIZE_535: usize = 3; -const IN_535: usize = 3; -const OUT_535: usize = 0; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_534: usize = 3; +const IN_534: usize = 3; +const OUT_534: usize = 0; +fn aiur_fn_534( + inp: [G; IN_534], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_535], 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]; @@ -44670,14 +46449,16 @@ fn aiur_fn_535( 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_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -44696,62 +46477,69 @@ fn aiur_fn_535( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_534] = { let __args: [G; IN_534] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_535] = []; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44761,15 +46549,15 @@ fn aiur_fn_535( }) } -const INPUT_SIZE_536: usize = 0; -const IN_536: usize = 0; -const OUT_536: usize = 1; -fn aiur_fn_536( - inp: [G; IN_536], +const INPUT_SIZE_535: usize = 0; +const IN_535: usize = 0; +const OUT_535: usize = 1; +fn aiur_fn_535( + inp: [G; IN_535], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_536], ExecError> { +) -> Result<[G; OUT_535], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(104); @@ -44803,22 +46591,23 @@ fn aiur_fn_536( let __v_29: G = G::from_u64(99); let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(184); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_536] = [__v_32]; - record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_535] = [__v_32]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_537: usize = 3; -const IN_537: usize = 3; -const OUT_537: usize = 1; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_536: usize = 3; +const IN_536: usize = 3; +const OUT_536: usize = 1; +fn aiur_fn_536( + inp: [G; IN_536], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_537], ExecError> { +) -> Result<[G; OUT_536], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44827,8 +46616,9 @@ fn aiur_fn_537( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_537] = [__v_4]; - record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_4]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44841,16 +46631,18 @@ fn aiur_fn_537( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_537] = [__v_10]; - record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_10]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_537] = [__v_8]; - record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_8]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44859,15 +46651,15 @@ fn aiur_fn_537( }) } -const INPUT_SIZE_538: usize = 0; -const IN_538: usize = 0; -const OUT_538: usize = 0; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_537: usize = 0; +const IN_537: usize = 0; +const OUT_537: usize = 0; +fn aiur_fn_537( + inp: [G; IN_537], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_538], ExecError> { +) -> Result<[G; OUT_537], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(3); let __v_1: G = G::from_u64(107); @@ -44901,7 +46693,7 @@ fn aiur_fn_538( let __v_29: G = G::from_u64(200); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(201); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; @@ -44931,8 +46723,9 @@ fn aiur_fn_538( if (__v_39 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } - let __ret: [G; OUT_538] = []; - record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_537] = []; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44942,15 +46735,15 @@ fn aiur_fn_538( }) } -const INPUT_SIZE_539: usize = 4; -const IN_539: usize = 4; -const OUT_539: usize = 0; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_538: usize = 4; +const IN_538: usize = 4; +const OUT_538: usize = 0; +fn aiur_fn_538( + inp: [G; IN_538], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], 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]; @@ -44958,7 +46751,7 @@ fn aiur_fn_539( let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -44971,7 +46764,7 @@ fn aiur_fn_539( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -44984,8 +46777,8 @@ fn aiur_fn_539( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -44998,7 +46791,7 @@ fn aiur_fn_539( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -45021,34 +46814,36 @@ fn aiur_fn_539( 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_537] = { let __args: [G; IN_537] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __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_539] = []; - record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_538] = []; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_540: usize = 2; -const IN_540: usize = 2; -const OUT_540: usize = 1; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_539: usize = 2; +const IN_539: usize = 2; +const OUT_539: usize = 1; +fn aiur_fn_539( + inp: [G; IN_539], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_540], ExecError> { +) -> Result<[G; OUT_539], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_540] = [__v_0]; - record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_539] = [__v_0]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45061,10 +46856,11 @@ fn aiur_fn_540( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_8]; - record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_539] = [__v_8]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45076,29 +46872,30 @@ fn aiur_fn_540( }) } -const INPUT_SIZE_541: usize = 3; -const IN_541: usize = 3; -const OUT_541: usize = 0; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_540: usize = 3; +const IN_540: usize = 3; +const OUT_540: usize = 0; +fn aiur_fn_540( + inp: [G; IN_540], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_541], 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 __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_541] = []; - record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_540] = []; + record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45118,12 +46915,13 @@ fn aiur_fn_541( 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_541] = { let __args: [G; IN_541] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; 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_541] = []; - record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_540] = []; + record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45140,15 +46938,15 @@ fn aiur_fn_541( }) } -const INPUT_SIZE_542: usize = 4; -const IN_542: usize = 4; -const OUT_542: usize = 0; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_541: usize = 4; +const IN_541: usize = 4; +const OUT_541: usize = 0; +fn aiur_fn_541( + inp: [G; IN_541], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_542], 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]; @@ -45157,8 +46955,9 @@ fn aiur_fn_542( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_542] = []; - record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_541] = []; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45177,7 +46976,7 @@ fn aiur_fn_542( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -45185,8 +46984,9 @@ fn aiur_fn_542( 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_542] = []; - record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_541] = []; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45203,15 +47003,15 @@ fn aiur_fn_542( }) } -const INPUT_SIZE_543: usize = 3; -const IN_543: usize = 3; -const OUT_543: usize = 0; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_542: usize = 3; +const IN_542: usize = 3; +const OUT_542: usize = 0; +fn aiur_fn_542( + inp: [G; IN_542], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_543], 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]; @@ -45242,8 +47042,9 @@ fn aiur_fn_543( 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_543] = []; - record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_542] = []; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45253,15 +47054,15 @@ fn aiur_fn_543( }) } -const INPUT_SIZE_544: usize = 7; -const IN_544: usize = 7; -const OUT_544: usize = 0; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_543: usize = 7; +const IN_543: usize = 7; +const OUT_543: usize = 0; +fn aiur_fn_543( + inp: [G; IN_543], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_544], 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]; @@ -45271,7 +47072,7 @@ fn aiur_fn_544( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -45283,32 +47084,33 @@ fn aiur_fn_544( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_555] = { let __args: [G; IN_555] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } - let __ret: [G; OUT_544] = []; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_543] = []; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45318,15 +47120,15 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 4; -const IN_545: usize = 4; -const OUT_545: usize = 0; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_544: usize = 4; +const IN_544: usize = 4; +const OUT_544: usize = 0; +fn aiur_fn_544( + inp: [G; IN_544], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_545], 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]; @@ -45334,8 +47136,9 @@ fn aiur_fn_545( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_545] = []; - record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_544] = []; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45353,19 +47156,20 @@ fn aiur_fn_545( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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_545] = { let __args: [G; IN_545] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_545] = []; - record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_544] = []; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45382,43 +47186,44 @@ fn aiur_fn_545( }) } -const INPUT_SIZE_546: usize = 3; -const IN_546: usize = 3; -const OUT_546: usize = 0; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_545: usize = 3; +const IN_545: usize = 3; +const OUT_545: usize = 0; +fn aiur_fn_545( + inp: [G; IN_545], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_546], 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 __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_546] = []; - record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_545] = []; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_547: usize = 3; -const IN_547: usize = 3; -const OUT_547: usize = 1; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_546: usize = 3; +const IN_546: usize = 3; +const OUT_546: usize = 1; +fn aiur_fn_546( + inp: [G; IN_546], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_547], 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { @@ -45429,8 +47234,9 @@ fn aiur_fn_547( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_547] = [__v_5]; - record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_546] = [__v_5]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45449,11 +47255,12 @@ fn aiur_fn_547( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_547] = [__v_12]; - record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_546] = [__v_12]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45465,15 +47272,15 @@ fn aiur_fn_547( }) } -const INPUT_SIZE_548: usize = 3; -const IN_548: usize = 3; -const OUT_548: usize = 0; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_547: usize = 3; +const IN_547: usize = 3; +const OUT_547: usize = 0; +fn aiur_fn_547( + inp: [G; IN_547], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_548], 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]; @@ -45485,39 +47292,41 @@ fn aiur_fn_548( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor field lives in a universe above the inductive's".to_string()) }); } let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_548] = []; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_547] = []; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_548] = []; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_547] = []; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_549: usize = 4; -const IN_549: usize = 4; -const OUT_549: usize = 0; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_548: usize = 4; +const IN_548: usize = 4; +const OUT_548: usize = 0; +fn aiur_fn_548( + inp: [G; IN_548], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_549], 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]; @@ -45525,9 +47334,10 @@ fn aiur_fn_549( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_549] = []; - record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_548] = []; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45541,10 +47351,11 @@ fn aiur_fn_549( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_549] = []; - record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_548] = []; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45556,15 +47367,15 @@ fn aiur_fn_549( }) } -const INPUT_SIZE_550: usize = 3; -const IN_550: usize = 3; -const OUT_550: usize = 0; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_549: usize = 3; +const IN_549: usize = 3; +const OUT_549: usize = 0; +fn aiur_fn_549( + inp: [G; IN_549], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_550], 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]; @@ -45575,52 +47386,55 @@ fn aiur_fn_550( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_550] = []; - record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_549] = []; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_550] = []; - record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_549] = []; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_551: usize = 2; -const IN_551: usize = 2; -const OUT_551: usize = 1; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_550: usize = 2; +const IN_550: usize = 2; +const OUT_550: usize = 1; +fn aiur_fn_550( + inp: [G; IN_550], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_551], 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 __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_551] = [__v_2]; - record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_550] = [__v_2]; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_552: usize = 2; -const IN_552: usize = 2; -const OUT_552: usize = 1; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_551: usize = 2; +const IN_551: usize = 2; +const OUT_551: usize = 1; +fn aiur_fn_551( + inp: [G; IN_551], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_552], 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]; @@ -45631,8 +47445,9 @@ fn aiur_fn_552( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_552] = [__v_5]; - record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_551] = [__v_5]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45641,15 +47456,17 @@ fn aiur_fn_552( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_552] = [__v_6]; - record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_551] = [__v_6]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_552] = [__v_6]; - record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_551] = [__v_6]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45661,15 +47478,15 @@ fn aiur_fn_552( }) } -const INPUT_SIZE_553: usize = 2; -const IN_553: usize = 2; -const OUT_553: usize = 1; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_552: usize = 2; +const IN_552: usize = 2; +const OUT_552: usize = 1; +fn aiur_fn_552( + inp: [G; IN_552], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_553], 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]; @@ -45690,31 +47507,33 @@ fn aiur_fn_553( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_15]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_15]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_553] = [__v_15]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_15]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_554: usize = 2; -const IN_554: usize = 2; -const OUT_554: usize = 1; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_553: usize = 2; +const IN_553: usize = 2; +const OUT_553: usize = 1; +fn aiur_fn_553( + inp: [G; IN_553], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_554], 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]; @@ -45726,105 +47545,117 @@ fn aiur_fn_554( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_554] = [__v_6]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_6]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_554] = [__v_6]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_6]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_6]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_6]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_554] = [__v_7]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_7]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_7]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_7]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_554] = [__v_7]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_7]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_7]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_7]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_554] = [__v_7]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_7]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_7]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_7]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_554] = [__v_7]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_7]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_554] = [__v_8]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_8]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_8]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_8]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45833,15 +47664,17 @@ fn aiur_fn_554( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_554] = [__v_6]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_6]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_6]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_6]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45851,15 +47684,15 @@ fn aiur_fn_554( }) } -const INPUT_SIZE_555: usize = 2; -const IN_555: usize = 2; -const OUT_555: usize = 1; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_554: usize = 2; +const IN_554: usize = 2; +const OUT_554: usize = 1; +fn aiur_fn_554( + inp: [G; IN_554], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_555], 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]; @@ -45870,25 +47703,28 @@ fn aiur_fn_555( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_555] = [__v_5]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_5]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_555] = [__v_6]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_6]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_555] = [__v_6]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_6]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45900,23 +47736,24 @@ fn aiur_fn_555( }) } -const INPUT_SIZE_556: usize = 3; -const IN_556: usize = 3; -const OUT_556: usize = 2; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_555: usize = 3; +const IN_555: usize = 3; +const OUT_555: usize = 2; +fn aiur_fn_555( + inp: [G; IN_555], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_556], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_556] = [__v_0, __v_2]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_0, __v_2]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45928,19 +47765,21 @@ fn aiur_fn_556( match __v_3.as_canonical_u64() { 5u64 => { let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_556] = [__v_11, __v_12]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_11, __v_12]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_556] = [__v_0, __v_2]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_0, __v_2]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45949,15 +47788,15 @@ fn aiur_fn_556( }) } -const INPUT_SIZE_557: usize = 4; -const IN_557: usize = 4; -const OUT_557: usize = 0; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_556: usize = 4; +const IN_556: usize = 4; +const OUT_556: usize = 0; +fn aiur_fn_556( + inp: [G; IN_556], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_557], 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]; @@ -45966,8 +47805,9 @@ fn aiur_fn_557( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_557] = []; - record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = []; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45992,9 +47832,10 @@ fn aiur_fn_557( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_557] = []; - record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_556] = []; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46011,15 +47852,15 @@ fn aiur_fn_557( }) } -const INPUT_SIZE_558: usize = 5; -const IN_558: usize = 5; -const OUT_558: usize = 0; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_557: usize = 5; +const IN_557: usize = 5; +const OUT_557: usize = 0; +fn aiur_fn_557( + inp: [G; IN_557], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_558], 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]; @@ -46044,25 +47885,26 @@ fn aiur_fn_558( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_729] = { let __args: [G; IN_729] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } - let __ret: [G; OUT_558] = []; - record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = []; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46072,30 +47914,31 @@ fn aiur_fn_558( }) } -const INPUT_SIZE_559: usize = 4; -const IN_559: usize = 4; -const OUT_559: usize = 0; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_558: usize = 4; +const IN_558: usize = 4; +const OUT_558: usize = 0; +fn aiur_fn_558( + inp: [G; IN_558], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_559], 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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_559] = []; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -46105,16 +47948,17 @@ fn aiur_fn_559( match __v_6.as_canonical_u64() { 5u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_559] = { let __args: [G; IN_559] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_559] = []; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46128,22 +47972,24 @@ fn aiur_fn_559( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __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_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_559] = []; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_559] = []; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46166,24 +48012,25 @@ fn aiur_fn_559( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_559] = []; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46204,15 +48051,15 @@ fn aiur_fn_559( }) } -const INPUT_SIZE_560: usize = 7; -const IN_560: usize = 7; -const OUT_560: usize = 0; -fn aiur_fn_560( - inp: [G; IN_560], +const INPUT_SIZE_559: usize = 7; +const IN_559: usize = 7; +const OUT_559: usize = 0; +fn aiur_fn_559( + inp: [G; IN_559], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_560], 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]; @@ -46224,8 +48071,9 @@ fn aiur_fn_560( let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_560] = []; - record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46248,23 +48096,24 @@ fn aiur_fn_560( 6u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __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_339] = { let __args: [G; IN_339] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_560] = []; - record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46276,15 +48125,15 @@ fn aiur_fn_560( }) } -const INPUT_SIZE_561: usize = 4; -const IN_561: usize = 4; -const OUT_561: usize = 0; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_560: usize = 4; +const IN_560: usize = 4; +const OUT_560: usize = 0; +fn aiur_fn_560( + inp: [G; IN_560], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_561], 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]; @@ -46297,32 +48146,34 @@ fn aiur_fn_561( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_561] = []; - record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_560] = []; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_561] = []; - record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_560] = []; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_562: usize = 4; -const IN_562: usize = 4; -const OUT_562: usize = 0; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_561: usize = 4; +const IN_561: usize = 4; +const OUT_561: usize = 0; +fn aiur_fn_561( + inp: [G; IN_561], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_562], 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]; @@ -46331,28 +48182,29 @@ fn aiur_fn_562( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __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_561] = { let __args: [G; IN_561] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_562] = []; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_561] = []; + record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_563: usize = 7; -const IN_563: usize = 7; -const OUT_563: usize = 0; -fn aiur_fn_563( - inp: [G; IN_563], +const INPUT_SIZE_562: usize = 7; +const IN_562: usize = 7; +const OUT_562: usize = 0; +fn aiur_fn_562( + inp: [G; IN_562], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_563], 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]; @@ -46364,26 +48216,27 @@ fn aiur_fn_563( let __v_7: G = (__v_1 + __v_2); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_563] = []; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_562] = []; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_564: usize = 9; -const IN_564: usize = 9; -const OUT_564: usize = 0; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_563: usize = 9; +const IN_563: usize = 9; +const OUT_563: usize = 0; +fn aiur_fn_563( + inp: [G; IN_563], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_564], 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]; @@ -46397,8 +48250,9 @@ fn aiur_fn_564( let __v_9: G = (__v_3 - __v_8); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_564] = []; - record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_563] = []; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46419,13 +48273,13 @@ fn aiur_fn_564( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_13, __v_17, __v_2, __v_18, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_13, __v_17, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_13, __v_17, __v_2, __v_18, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_13, __v_17, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_13, __v_17, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_13, __v_17, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_14, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); @@ -46443,9 +48297,10 @@ fn aiur_fn_564( } let __v_28: G = G::from_u64(1); let __v_29: G = (__v_8 + __v_28); - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_564] = []; - record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_563] = []; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46457,15 +48312,15 @@ fn aiur_fn_564( }) } -const INPUT_SIZE_565: usize = 12; -const IN_565: usize = 12; -const OUT_565: usize = 0; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_564: usize = 12; +const IN_564: usize = 12; +const OUT_564: usize = 0; +fn aiur_fn_564( + inp: [G; IN_564], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_565], 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]; @@ -46481,29 +48336,31 @@ fn aiur_fn_565( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_565] = []; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_564] = []; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_565] = []; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = []; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_566: usize = 13; -const IN_566: usize = 13; -const OUT_566: usize = 0; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_565: usize = 13; +const IN_565: usize = 13; +const OUT_565: usize = 0; +fn aiur_fn_565( + inp: [G; IN_565], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_566], 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]; @@ -46524,8 +48381,9 @@ fn aiur_fn_566( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_565] = []; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46583,14 +48441,16 @@ fn aiur_fn_566( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_565] = []; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_565] = []; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46600,23 +48460,24 @@ fn aiur_fn_566( } }, _ => { - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_565] = []; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_567: usize = 7; -const IN_567: usize = 7; -const OUT_567: usize = 0; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_566: usize = 7; +const IN_566: usize = 7; +const OUT_566: usize = 0; +fn aiur_fn_566( + inp: [G; IN_566], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_567], 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]; @@ -46675,8 +48536,9 @@ fn aiur_fn_567( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_567] = []; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -46688,9 +48550,10 @@ fn aiur_fn_567( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_567] = []; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46711,23 +48574,23 @@ fn aiur_fn_567( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); - let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __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_298] = { let __args: [G; IN_298] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -46735,17 +48598,19 @@ fn aiur_fn_567( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_567] = []; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_567] = []; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46755,9 +48620,10 @@ fn aiur_fn_567( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_567] = []; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46769,15 +48635,15 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 15; -const IN_568: usize = 15; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_567: usize = 15; +const IN_567: usize = 15; +const OUT_567: usize = 1; +fn aiur_fn_567( + inp: [G; IN_567], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_568], 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]; @@ -46799,24 +48665,27 @@ fn aiur_fn_568( match __v_15.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_568] = [__v_16]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_16]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_568] = [__v_16]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_16]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_568] = [__v_16]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_16]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46825,26 +48694,29 @@ fn aiur_fn_568( match __v_10.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_568] = [__v_16]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_16]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_5, __v_9, __v_10, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_5, __v_9, __v_10, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_19]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_19]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_568] = [__v_16]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_16]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46853,8 +48725,9 @@ fn aiur_fn_568( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_568] = [__v_16]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_16]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46863,15 +48736,15 @@ fn aiur_fn_568( }) } -const INPUT_SIZE_569: usize = 4; -const IN_569: usize = 4; -const OUT_569: usize = 1; -fn aiur_fn_569( - inp: [G; IN_569], +const INPUT_SIZE_568: usize = 4; +const IN_568: usize = 4; +const OUT_568: usize = 1; +fn aiur_fn_568( + inp: [G; IN_568], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_569], 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]; @@ -46882,11 +48755,12 @@ fn aiur_fn_569( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_8]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_8]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46898,19 +48772,21 @@ fn aiur_fn_569( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_12]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_12]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_8]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_8]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46919,15 +48795,15 @@ fn aiur_fn_569( }) } -const INPUT_SIZE_570: usize = 5; -const IN_570: usize = 5; -const OUT_570: usize = 1; -fn aiur_fn_570( - inp: [G; IN_570], +const INPUT_SIZE_569: usize = 5; +const IN_569: usize = 5; +const OUT_569: usize = 1; +fn aiur_fn_569( + inp: [G; IN_569], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_570], 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]; @@ -46940,10 +48816,11 @@ fn aiur_fn_570( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_8]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_569] = [__v_8]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46954,13 +48831,13 @@ fn aiur_fn_570( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -46972,26 +48849,28 @@ fn aiur_fn_570( }, _ => { let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_0 [__v_21]; }, } }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_25]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_569] = [__v_25]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_570] = [__v_10]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_569] = [__v_10]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47000,15 +48879,15 @@ fn aiur_fn_570( }) } -const INPUT_SIZE_571: usize = 2; -const IN_571: usize = 2; -const OUT_571: usize = 1; -fn aiur_fn_571( - inp: [G; IN_571], +const INPUT_SIZE_570: usize = 2; +const IN_570: usize = 2; +const OUT_570: usize = 1; +fn aiur_fn_570( + inp: [G; IN_570], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_571], 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]; @@ -47019,25 +48898,28 @@ fn aiur_fn_571( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_571] = [__v_5]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_5]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __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_571] = [__v_6]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_6]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_6]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_6]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47049,15 +48931,15 @@ 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_571: usize = 2; +const IN_571: usize = 2; +const OUT_571: usize = 1; +fn aiur_fn_571( + inp: [G; IN_571], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_572], 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]; @@ -47068,8 +48950,9 @@ fn aiur_fn_572( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_5]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_5]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -47084,24 +48967,27 @@ fn aiur_fn_572( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_572] = [__v_10]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_10]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_572] = [__v_10]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_10]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_572] = [__v_9]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_9]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47113,15 +48999,15 @@ fn aiur_fn_572( }) } -const INPUT_SIZE_573: usize = 13; -const IN_573: usize = 13; -const OUT_573: usize = 1; -fn aiur_fn_573( - inp: [G; IN_573], +const INPUT_SIZE_572: usize = 13; +const IN_572: usize = 13; +const OUT_572: usize = 1; +fn aiur_fn_572( + inp: [G; IN_572], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_573], 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]; @@ -47138,32 +49024,34 @@ fn aiur_fn_573( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __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_573] = [__v_14]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_14]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = (__v_3 + __v_4); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_23]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_23]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47188,22 +49076,25 @@ fn aiur_fn_573( match __v_25.as_canonical_u64() { 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); - let __ret: [G; OUT_573] = [__v_37]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_37]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_37]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_37]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_23]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_23]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47214,23 +49105,24 @@ fn aiur_fn_573( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_13]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_13]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_574: usize = 2; -const IN_574: usize = 2; -const OUT_574: usize = 1; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_573: usize = 2; +const IN_573: usize = 2; +const OUT_573: usize = 1; +fn aiur_fn_573( + inp: [G; IN_573], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_574], 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]; @@ -47239,8 +49131,9 @@ fn aiur_fn_574( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_3]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_3]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47298,16 +49191,18 @@ fn aiur_fn_574( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_52]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_52]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_574] = [__v_51]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_51]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47318,15 +49213,15 @@ fn aiur_fn_574( }) } -const INPUT_SIZE_575: usize = 1; -const IN_575: usize = 1; -const OUT_575: usize = 1; -fn aiur_fn_575( - inp: [G; IN_575], +const INPUT_SIZE_574: usize = 1; +const IN_574: usize = 1; +const OUT_574: usize = 1; +fn aiur_fn_574( + inp: [G; IN_574], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_575], ExecError> { +) -> Result<[G; OUT_574], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; @@ -47383,14 +49278,16 @@ fn aiur_fn_575( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_575] = [__v_49]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_49]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_49]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_49]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47399,15 +49296,15 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 2; -const IN_576: usize = 2; -const OUT_576: usize = 1; -fn aiur_fn_576( - inp: [G; IN_576], +const INPUT_SIZE_575: usize = 2; +const IN_575: usize = 2; +const OUT_575: usize = 1; +fn aiur_fn_575( + inp: [G; IN_575], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_576], 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]; @@ -47464,14 +49361,16 @@ fn aiur_fn_576( match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_49]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_49]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_576] = [__v_49]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_49]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47481,17 +49380,19 @@ fn aiur_fn_576( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_576] = [__v_51]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_51]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_576] = [__v_49]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_49]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47503,15 +49404,15 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 5; -const IN_577: usize = 5; -const OUT_577: usize = 1; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_576: usize = 5; +const IN_576: usize = 5; +const OUT_576: usize = 1; +fn aiur_fn_576( + inp: [G; IN_576], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_577], ExecError> { +) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47521,7 +49422,7 @@ fn aiur_fn_577( 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_540] = { let __args: [G; IN_540] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -47540,8 +49441,9 @@ fn aiur_fn_577( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_577] = [__v_16]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_16]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47556,15 +49458,15 @@ fn aiur_fn_577( }) } -const INPUT_SIZE_578: usize = 12; -const IN_578: usize = 12; -const OUT_578: usize = 1; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_577: usize = 12; +const IN_577: usize = 12; +const OUT_577: usize = 1; +fn aiur_fn_577( + inp: [G; IN_577], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_578], ExecError> { +) -> Result<[G; OUT_577], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47583,7 +49485,7 @@ fn aiur_fn_578( 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_540] = { let __args: [G; IN_540] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -47602,16 +49504,18 @@ fn aiur_fn_578( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_578] = [__v_24]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_24]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_578] = [__v_28]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_577] = [__v_28]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47619,9 +49523,10 @@ fn aiur_fn_578( _ => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_578] = [__v_22]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_577] = [__v_22]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47629,24 +49534,25 @@ fn aiur_fn_578( _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_578] = [__v_14]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_577] = [__v_14]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_579: usize = 6; -const IN_579: usize = 6; -const OUT_579: usize = 1; -fn aiur_fn_579( - inp: [G; IN_579], +const INPUT_SIZE_578: usize = 6; +const IN_578: usize = 6; +const OUT_578: usize = 1; +fn aiur_fn_578( + inp: [G; IN_578], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_579], 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]; @@ -47657,7 +49563,7 @@ fn aiur_fn_579( 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_540] = { let __args: [G; IN_540] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -47669,14 +49575,15 @@ fn aiur_fn_579( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __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_580] = { let __args: [G; IN_580] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_579] = [__v_19]; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_19]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47686,15 +49593,15 @@ fn aiur_fn_579( }) } -const INPUT_SIZE_580: usize = 2; -const IN_580: usize = 2; -const OUT_580: usize = 1; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_579: usize = 2; +const IN_579: usize = 2; +const OUT_579: usize = 1; +fn aiur_fn_579( + inp: [G; IN_579], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], 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]; @@ -47706,14 +49613,15 @@ fn aiur_fn_580( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_580] = [__v_7]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_579] = [__v_7]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -47721,13 +49629,14 @@ fn aiur_fn_580( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_580] = [__v_12]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_579] = [__v_12]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47737,15 +49646,15 @@ fn aiur_fn_580( }) } -const INPUT_SIZE_581: usize = 3; -const IN_581: usize = 3; -const OUT_581: usize = 1; -fn aiur_fn_581( - inp: [G; IN_581], +const INPUT_SIZE_580: usize = 3; +const IN_580: usize = 3; +const OUT_580: usize = 1; +fn aiur_fn_580( + inp: [G; IN_580], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_581], ExecError> { +) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47755,9 +49664,10 @@ fn aiur_fn_581( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_581] = [__v_6]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_580] = [__v_6]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47765,29 +49675,30 @@ fn aiur_fn_581( let __v_5: G = G::from_u64(4); let __v_6: G = (__v_0 + __v_2); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_581] = [__v_12]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_580] = [__v_12]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_582: usize = 2; -const IN_582: usize = 2; -const OUT_582: usize = 1; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_581: usize = 2; +const IN_581: usize = 2; +const OUT_581: usize = 1; +fn aiur_fn_581( + inp: [G; IN_581], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_582], 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]; @@ -47845,10 +49756,11 @@ fn aiur_fn_582( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_582] = [__v_51]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_51]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47870,27 +49782,29 @@ fn aiur_fn_582( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(1); - let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_582] = [__v_73]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_581] = [__v_73]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); - let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_582] = [__v_65]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_581] = [__v_65]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47901,15 +49815,15 @@ fn aiur_fn_582( }) } -const INPUT_SIZE_583: usize = 5; -const IN_583: usize = 5; -const OUT_583: usize = 1; -fn aiur_fn_583( - inp: [G; IN_583], +const INPUT_SIZE_582: usize = 5; +const IN_582: usize = 5; +const OUT_582: usize = 1; +fn aiur_fn_582( + inp: [G; IN_582], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_583], ExecError> { +) -> Result<[G; OUT_582], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47968,9 +49882,10 @@ fn aiur_fn_583( 1u64 => { let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_583] = [__v_54]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_582] = [__v_54]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -48005,29 +49920,31 @@ fn aiur_fn_583( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); let __v_71: G = G::from_u64(1); let __v_72: G = G::from_u64(1); - let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_583] = [__v_77]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_582] = [__v_77]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_4 + __v_52); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_54]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_54]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48039,15 +49956,15 @@ fn aiur_fn_583( }) } -const INPUT_SIZE_584: usize = 3; -const IN_584: usize = 3; -const OUT_584: usize = 1; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_583: usize = 3; +const IN_583: usize = 3; +const OUT_583: usize = 1; +fn aiur_fn_583( + inp: [G; IN_583], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_584], 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]; @@ -48062,8 +49979,9 @@ fn aiur_fn_584( match __v_3.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_9]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_9]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -48073,38 +49991,42 @@ fn aiur_fn_584( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __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_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_11]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_11]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_10]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_10]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_9]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_9]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48116,15 +50038,15 @@ fn aiur_fn_584( }) } -const INPUT_SIZE_585: usize = 2; -const IN_585: usize = 2; -const OUT_585: usize = 1; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_584: usize = 2; +const IN_584: usize = 2; +const OUT_584: usize = 1; +fn aiur_fn_584( + inp: [G; IN_584], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_585], 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]; @@ -48132,8 +50054,9 @@ fn aiur_fn_585( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_585] = [__v_3]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_3]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48155,22 +50078,25 @@ fn aiur_fn_585( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48183,16 +50109,18 @@ fn aiur_fn_585( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48209,24 +50137,27 @@ fn aiur_fn_585( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48239,28 +50170,31 @@ fn aiur_fn_585( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48273,28 +50207,31 @@ fn aiur_fn_585( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48307,28 +50244,31 @@ fn aiur_fn_585( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48341,40 +50281,44 @@ fn aiur_fn_585( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_13]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_13]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_13]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_13]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48387,16 +50331,18 @@ fn aiur_fn_585( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48416,32 +50362,36 @@ fn aiur_fn_585( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_13]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_13]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_13]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_13]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_12]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_12]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_11]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48455,15 +50405,15 @@ fn aiur_fn_585( }) } -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_585: usize = 2; +const IN_585: usize = 2; +const OUT_585: usize = 1; +fn aiur_fn_585( + inp: [G; IN_585], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_586], 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]; @@ -48480,14 +50430,16 @@ fn aiur_fn_586( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_586] = [__v_8]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_8]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_586] = [__v_8]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_8]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48500,25 +50452,28 @@ fn aiur_fn_586( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_586] = [__v_8]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_8]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_586] = [__v_9]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_9]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_586] = [__v_9]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_9]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48535,15 +50490,15 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 2; -const IN_587: usize = 2; -const OUT_587: usize = 1; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_586: usize = 2; +const IN_586: usize = 2; +const OUT_586: usize = 1; +fn aiur_fn_586( + inp: [G; IN_586], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], 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]; @@ -48560,14 +50515,16 @@ fn aiur_fn_587( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_587] = [__v_8]; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_8]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_587] = [__v_8]; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_8]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48580,25 +50537,28 @@ fn aiur_fn_587( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_587] = [__v_8]; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_8]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_587] = [__v_9]; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_9]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_587] = [__v_9]; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_9]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48615,15 +50575,15 @@ fn aiur_fn_587( }) } -const INPUT_SIZE_588: usize = 13; -const IN_588: usize = 13; -const OUT_588: usize = 1; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_587: usize = 13; +const IN_587: usize = 13; +const OUT_587: usize = 1; +fn aiur_fn_587( + inp: [G; IN_587], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], ExecError> { +) -> Result<[G; OUT_587], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48640,33 +50600,35 @@ fn aiur_fn_588( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_588] = [__v_13]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_13]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_588] = [__v_15]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_587] = [__v_15]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_589: usize = 2; -const IN_589: usize = 2; -const OUT_589: usize = 1; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_588: usize = 2; +const IN_588: usize = 2; +const OUT_588: usize = 1; +fn aiur_fn_588( + inp: [G; IN_588], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_589], ExecError> { +) -> Result<[G; OUT_588], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48724,15 +50686,17 @@ fn aiur_fn_589( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_589] = [__v_51]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_51]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_589] = [__v_1]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_1]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48741,15 +50705,15 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 5; -const IN_590: usize = 5; -const OUT_590: usize = 1; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_589: usize = 5; +const IN_589: usize = 5; +const OUT_589: usize = 1; +fn aiur_fn_589( + inp: [G; IN_589], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], 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]; @@ -48806,8 +50770,9 @@ fn aiur_fn_590( let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_590] = [__v_4]; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_4]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -48832,7 +50797,7 @@ fn aiur_fn_590( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; @@ -48851,20 +50816,23 @@ fn aiur_fn_590( let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_590] = [__v_75]; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_75]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_590] = [__v_4]; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_4]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_590] = [__v_4]; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_4]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48872,10 +50840,11 @@ fn aiur_fn_590( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_590] = [__v_54]; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_54]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48887,51 +50856,53 @@ fn aiur_fn_590( }) } -const INPUT_SIZE_591: usize = 3; -const IN_591: usize = 3; -const OUT_591: usize = 1; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_590: usize = 3; +const IN_590: usize = 3; +const OUT_590: usize = 1; +fn aiur_fn_590( + inp: [G; IN_590], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_591], ExecError> { +) -> Result<[G; OUT_590], ExecError> { stacker::maybe_grow(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_589] = { let __args: [G; IN_589] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_591] = [__v_4]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = [__v_4]; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_591] = [__v_6]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = [__v_6]; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_592: usize = 4; -const IN_592: usize = 4; -const OUT_592: usize = 1; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_591: usize = 4; +const IN_591: usize = 4; +const OUT_591: usize = 1; +fn aiur_fn_591( + inp: [G; IN_591], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_592], 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]; @@ -48991,15 +50962,17 @@ fn aiur_fn_592( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_53]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_53]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_592] = [__v_3]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_3]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49008,15 +50981,15 @@ fn aiur_fn_592( }) } -const INPUT_SIZE_593: usize = 7; -const IN_593: usize = 7; -const OUT_593: usize = 1; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_592: usize = 7; +const IN_592: usize = 7; +const OUT_592: usize = 1; +fn aiur_fn_592( + inp: [G; IN_592], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_593], 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]; @@ -49075,8 +51048,9 @@ fn aiur_fn_593( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_593] = [__v_5]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_5]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -49101,7 +51075,7 @@ fn aiur_fn_593( 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_577] = { let __args: [G; IN_577] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; @@ -49162,39 +51136,42 @@ fn aiur_fn_593( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_75]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_75]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __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_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_78]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_78]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __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_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_80]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_80]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49204,10 +51181,11 @@ fn aiur_fn_593( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_56]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_56]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49219,15 +51197,15 @@ fn aiur_fn_593( }) } -const INPUT_SIZE_594: usize = 3; -const IN_594: usize = 3; -const OUT_594: usize = 2; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_593: usize = 3; +const IN_593: usize = 3; +const OUT_593: usize = 2; +fn aiur_fn_593( + inp: [G; IN_593], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_594], 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]; @@ -49243,8 +51221,9 @@ fn aiur_fn_594( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_594] = [__v_9, __v_10]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_9, __v_10]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -49253,18 +51232,20 @@ fn aiur_fn_594( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_594] = [__v_10, __v_2]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_10, __v_2]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_594] = [__v_12, __v_13]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_12, __v_13]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49276,15 +51257,15 @@ fn aiur_fn_594( }) } -const INPUT_SIZE_595: usize = 5; -const IN_595: usize = 5; -const OUT_595: usize = 2; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_594: usize = 5; +const IN_594: usize = 5; +const OUT_594: usize = 2; +fn aiur_fn_594( + inp: [G; IN_594], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], 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]; @@ -49302,8 +51283,9 @@ fn aiur_fn_595( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_595] = [__v_11, __v_12]; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_11, __v_12]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -49324,7 +51306,7 @@ fn aiur_fn_595( 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_587] = { let __args: [G; IN_587] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -49340,18 +51322,20 @@ fn aiur_fn_595( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_595] = [__v_17, __v_4]; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_17, __v_4]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_595] = [__v_19, __v_20]; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_19, __v_20]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49363,15 +51347,15 @@ fn aiur_fn_595( }) } -const INPUT_SIZE_596: usize = 2; -const IN_596: usize = 2; -const OUT_596: usize = 4; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_595: usize = 2; +const IN_595: usize = 2; +const OUT_595: usize = 4; +fn aiur_fn_595( + inp: [G; IN_595], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_596], 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]; @@ -49416,35 +51400,38 @@ fn aiur_fn_596( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_596] = [__v_40, __v_41, __v_44, __v_47]; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_595] = [__v_40, __v_41, __v_44, __v_47]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_596] = [__v_3, __v_4, __v_5, __v_6]; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_3, __v_4, __v_5, __v_6]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __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_596] = [__v_10, __v_11, __v_12, __v_13]; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_10, __v_11, __v_12, __v_13]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49456,15 +51443,15 @@ fn aiur_fn_596( }) } -const INPUT_SIZE_597: usize = 4; -const IN_597: usize = 4; -const OUT_597: usize = 1; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_596: usize = 4; +const IN_596: usize = 4; +const OUT_596: usize = 1; +fn aiur_fn_596( + inp: [G; IN_596], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_597], 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]; @@ -49477,21 +51464,23 @@ fn aiur_fn_597( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_597] = [__v_9]; - record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_596] = [__v_9]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_597] = [__v_6]; - record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_596] = [__v_6]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49500,9 +51489,10 @@ fn aiur_fn_597( let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_8 - __v_0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_597] = [__v_11]; - record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_596] = [__v_11]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49511,15 +51501,15 @@ fn aiur_fn_597( }) } -const INPUT_SIZE_598: usize = 6; -const IN_598: usize = 6; -const OUT_598: usize = 1; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_597: usize = 6; +const IN_597: usize = 6; +const OUT_597: usize = 1; +fn aiur_fn_597( + inp: [G; IN_597], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_598], 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]; @@ -49529,8 +51519,9 @@ fn aiur_fn_598( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_598] = [__v_0]; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_597] = [__v_0]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49541,19 +51532,20 @@ fn aiur_fn_598( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_598] = { let __args: [G; IN_598] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_598] = [__v_17]; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_597] = [__v_17]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49565,15 +51557,15 @@ 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_598: usize = 2; +const IN_598: usize = 2; +const OUT_598: usize = 1; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_599], 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]; @@ -49581,9 +51573,10 @@ fn aiur_fn_599( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_599] = [__v_4]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_598] = [__v_4]; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49597,11 +51590,12 @@ fn aiur_fn_599( 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_599] = { let __args: [G; IN_599] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_599] = [__v_10]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_598] = [__v_10]; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49613,15 +51607,15 @@ fn aiur_fn_599( }) } -const INPUT_SIZE_600: usize = 4; -const IN_600: usize = 4; -const OUT_600: usize = 1; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_599: usize = 4; +const IN_599: usize = 4; +const OUT_599: usize = 1; +fn aiur_fn_599( + inp: [G; IN_599], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_600], 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]; @@ -49630,8 +51624,9 @@ fn aiur_fn_600( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_600] = [__v_0]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_599] = [__v_0]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49641,31 +51636,32 @@ fn aiur_fn_600( let __v_8: G = (__v_7 - __v_3); let __v_9: G = (__v_8 + __v_2); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_17]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_599] = [__v_17]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_601: usize = 3; -const IN_601: usize = 3; -const OUT_601: usize = 1; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_600: usize = 3; +const IN_600: usize = 3; +const OUT_600: usize = 1; +fn aiur_fn_600( + inp: [G; IN_600], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_601], 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]; @@ -49676,21 +51672,23 @@ fn aiur_fn_601( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_601] = [__v_0]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_600] = [__v_0]; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_601] = [__v_11]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_600] = [__v_11]; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49700,15 +51698,15 @@ fn aiur_fn_601( }) } -const INPUT_SIZE_602: usize = 5; -const IN_602: usize = 5; -const OUT_602: usize = 1; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_601: usize = 5; +const IN_601: usize = 5; +const OUT_601: usize = 1; +fn aiur_fn_601( + inp: [G; IN_601], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_602], 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]; @@ -49718,32 +51716,34 @@ fn aiur_fn_602( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_6]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_601] = [__v_6]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_5]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_601] = [__v_5]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_603: usize = 3; -const IN_603: usize = 3; -const OUT_603: usize = 1; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_602: usize = 3; +const IN_602: usize = 3; +const OUT_602: usize = 1; +fn aiur_fn_602( + inp: [G; IN_602], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_603], 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]; @@ -49751,8 +51751,9 @@ fn aiur_fn_603( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_603] = [__v_0]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_0]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49761,31 +51762,32 @@ fn aiur_fn_603( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_2 + __v_13); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_603] = [__v_15]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_15]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_604: usize = 2; -const IN_604: usize = 2; -const OUT_604: usize = 1; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_603: usize = 2; +const IN_603: usize = 2; +const OUT_603: usize = 1; +fn aiur_fn_603( + inp: [G; IN_603], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], 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]; @@ -49795,18 +51797,20 @@ fn aiur_fn_604( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_604] = [__v_0]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_603] = [__v_0]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_604] = [__v_8]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_603] = [__v_8]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49816,15 +51820,15 @@ fn aiur_fn_604( }) } -const INPUT_SIZE_605: usize = 2; -const IN_605: usize = 2; -const OUT_605: usize = 2; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_604: usize = 2; +const IN_604: usize = 2; +const OUT_604: usize = 2; +fn aiur_fn_604( + inp: [G; IN_604], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_605], 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]; @@ -49832,9 +51836,10 @@ fn aiur_fn_605( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_605] = [__v_4, __v_0]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_604] = [__v_4, __v_0]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49847,20 +51852,21 @@ fn aiur_fn_605( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_605] = [__v_11, __v_9]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_604] = [__v_11, __v_9]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -49871,21 +51877,23 @@ fn aiur_fn_605( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_605] = [__v_19, __v_17]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_604] = [__v_19, __v_17]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_605] = [__v_16, __v_0]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_604] = [__v_16, __v_0]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49896,15 +51904,15 @@ fn aiur_fn_605( }) } -const INPUT_SIZE_606: usize = 3; -const IN_606: usize = 3; -const OUT_606: usize = 1; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_605: usize = 3; +const IN_605: usize = 3; +const OUT_605: usize = 1; +fn aiur_fn_605( + inp: [G; IN_605], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], 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]; @@ -49917,22 +51925,24 @@ fn aiur_fn_606( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_605] = [__v_8]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_606] = [__v_11]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_605] = [__v_11]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49942,15 +51952,15 @@ fn aiur_fn_606( }) } -const INPUT_SIZE_607: usize = 6; -const IN_607: usize = 6; -const OUT_607: usize = 1; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_606: usize = 6; +const IN_606: usize = 6; +const OUT_606: usize = 1; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], 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]; @@ -49960,33 +51970,35 @@ fn aiur_fn_607( let __v_5: G = inp[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_607] = [__v_6]; - record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_606] = [__v_6]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_607] = [__v_7]; - record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_608: usize = 3; -const IN_608: usize = 3; -const OUT_608: usize = 1; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_607: usize = 3; +const IN_607: usize = 3; +const OUT_607: usize = 1; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], 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]; @@ -49994,39 +52006,41 @@ fn aiur_fn_608( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_608] = [__v_0]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_607] = [__v_0]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_1 - __v_2); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_608] = [__v_13]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_607] = [__v_13]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_609: usize = 9; -const IN_609: usize = 9; -const OUT_609: usize = 1; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_608: usize = 9; +const IN_608: usize = 9; +const OUT_608: usize = 1; +fn aiur_fn_608( + inp: [G; IN_608], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], 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]; @@ -50037,66 +52051,68 @@ fn aiur_fn_609( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_15, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_15, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_609] = [__v_25]; - record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_608] = [__v_25]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_610: usize = 3; -const IN_610: usize = 3; -const OUT_610: usize = 1; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_609: usize = 3; +const IN_609: usize = 3; +const OUT_609: usize = 1; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_610], 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 = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_4]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_4]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_611: usize = 4; -const IN_611: usize = 4; -const OUT_611: usize = 1; -fn aiur_fn_611( - inp: [G; IN_611], +const INPUT_SIZE_610: usize = 4; +const IN_610: usize = 4; +const OUT_610: usize = 1; +fn aiur_fn_610( + inp: [G; IN_610], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_611], 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]; @@ -50105,39 +52121,41 @@ fn aiur_fn_611( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_611] = [__v_0]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_0]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = (__v_2 - __v_3); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_611] = [__v_14]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_14]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_612: usize = 2; -const IN_612: usize = 2; -const OUT_612: usize = 1; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_611: usize = 2; +const IN_611: usize = 2; +const OUT_611: usize = 1; +fn aiur_fn_611( + inp: [G; IN_611], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_612], 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]; @@ -50147,18 +52165,20 @@ fn aiur_fn_612( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_612] = [__v_0]; - record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_0]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_612] = [__v_8]; - record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_611] = [__v_8]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50168,15 +52188,15 @@ fn aiur_fn_612( }) } -const INPUT_SIZE_613: usize = 9; -const IN_613: usize = 9; -const OUT_613: usize = 1; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_612: usize = 9; +const IN_612: usize = 9; +const OUT_612: usize = 1; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_613], 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]; @@ -50188,7 +52208,7 @@ fn aiur_fn_613( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -50210,32 +52230,34 @@ fn aiur_fn_613( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_27]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_27]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_27]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_27]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_614: usize = 11; -const IN_614: usize = 11; -const OUT_614: usize = 1; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_613: usize = 11; +const IN_613: usize = 11; +const OUT_613: usize = 1; +fn aiur_fn_613( + inp: [G; IN_613], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_614], 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]; @@ -50248,36 +52270,36 @@ fn aiur_fn_614( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_16, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_16, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_11 + __v_19); let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __r_arr[2]; let __v_27: G = __r_arr[3]; 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_24, __v_27, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_24, __v_27, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_31: G = (__v_4 + __v_11); let __v_32: G = (__v_31 + __v_19); let __v_33: G = (__v_32 + __v_5); @@ -50285,10 +52307,10 @@ fn aiur_fn_614( let __v_35: G = (__v_33 - __v_34); let __v_36: G = (__v_11 + __v_19); let __v_37: G = (__v_36 + __v_5); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_30, __v_4, __v_35, __v_37, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_30, __v_4, __v_35, __v_37, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_38, __v_5, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_38, __v_5, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __v_42: G = (__v_33 + __v_41); @@ -50298,43 +52320,44 @@ fn aiur_fn_614( let __v_46: G = (__v_44 - __v_45); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_49, __v_5, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_49, __v_5, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(3); let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 4] = [__v_52, __v_51, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 4] = [__v_52, __v_51, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_59: G = G::from_u64(5); let __v_60: G = G::from_u64(0); - let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_61, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_61, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_62, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_62, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_63, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_63, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_64, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_64, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_65]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_65]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_615: usize = 26; -const IN_615: usize = 26; -const OUT_615: usize = 0; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_614: usize = 26; +const IN_614: usize = 26; +const OUT_614: usize = 0; +fn aiur_fn_614( + inp: [G; IN_614], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_615], 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]; @@ -50394,9 +52417,9 @@ fn aiur_fn_615( let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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]; @@ -50419,40 +52442,40 @@ fn aiur_fn_615( let __v_39: G = (__v_16 + __v_17); let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(4); 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_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_1 [__v_48]; }, _ => { let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_1 [__v_47]; }, } }; let __v_45: G = __mc_out___mc_1[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_10, __v_20, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_10, __v_20, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_48, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -50462,40 +52485,42 @@ fn aiur_fn_615( let __v_57: G = (__v_51 * __v_56); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_57.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; break '__mc_2 [__v_58]; }, _ => { let __v_58: G = G::from_u64(1); let __v_59: G = G::from_u64(1); - let __v_60: G = { let __values: [G; 3] = [__v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = { let __values: [G; 3] = [__v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_2 [__v_60]; }, } }; let __v_58: G = __mc_out___mc_2[0]; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_48, __v_25, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_48, __v_25, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; match __v_60.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_615] = []; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_614] = []; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_48, __v_25, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_48, __v_25, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; match __v_63.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_615] = []; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_614] = []; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50506,8 +52531,9 @@ fn aiur_fn_615( } }, _ => { - let __ret: [G; OUT_615] = []; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = []; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50519,15 +52545,15 @@ fn aiur_fn_615( }) } -const INPUT_SIZE_616: usize = 18; -const IN_616: usize = 18; -const OUT_616: usize = 0; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_615: usize = 18; +const IN_615: usize = 18; +const OUT_615: usize = 0; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], 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]; @@ -50547,45 +52573,46 @@ fn aiur_fn_616( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __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_613] = { let __args: [G; IN_613] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_24, __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_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_2, __v_24, __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_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); } let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_616] = []; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_615] = []; + record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_617: usize = 3; -const IN_617: usize = 3; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_616: usize = 3; +const IN_616: usize = 3; +const OUT_616: usize = 1; +fn aiur_fn_616( + inp: [G; IN_616], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_617], 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]; @@ -50594,8 +52621,9 @@ fn aiur_fn_617( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_617] = [__v_4]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_4]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50609,8 +52637,9 @@ fn aiur_fn_617( match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_617] = [__v_10]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -50642,11 +52671,12 @@ fn aiur_fn_617( 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_617] = { let __args: [G; IN_617] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); - let __ret: [G; OUT_617] = [__v_27]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_27]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50658,15 +52688,15 @@ fn aiur_fn_617( }) } -const INPUT_SIZE_618: usize = 15; -const IN_618: usize = 15; -const OUT_618: usize = 1; -fn aiur_fn_618( - inp: [G; IN_618], +const INPUT_SIZE_617: usize = 15; +const IN_617: usize = 15; +const OUT_617: usize = 1; +fn aiur_fn_617( + inp: [G; IN_617], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_618], 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]; @@ -50688,9 +52718,10 @@ fn aiur_fn_618( 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_618] = [__v_18]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_617] = [__v_18]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50712,24 +52743,26 @@ fn aiur_fn_618( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __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_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, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_618] = [__v_35]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_617] = [__v_35]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_618] = [__v_31]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_617] = [__v_31]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50738,15 +52771,15 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 9; -const IN_619: usize = 9; -const OUT_619: usize = 0; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_618: usize = 9; +const IN_618: usize = 9; +const OUT_618: usize = 0; +fn aiur_fn_618( + inp: [G; IN_618], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_619], 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]; @@ -50765,8 +52798,9 @@ fn aiur_fn_619( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_619] = []; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = []; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -50813,8 +52847,9 @@ fn aiur_fn_619( let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_619] = []; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = []; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -50824,8 +52859,8 @@ fn aiur_fn_619( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__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]; @@ -50834,8 +52869,8 @@ fn aiur_fn_619( } let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -50843,9 +52878,10 @@ fn aiur_fn_619( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_619] = []; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_618] = []; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50862,15 +52898,15 @@ fn aiur_fn_619( }) } -const INPUT_SIZE_620: usize = 12; -const IN_620: usize = 12; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_619: usize = 12; +const IN_619: usize = 12; +const OUT_619: usize = 1; +fn aiur_fn_619( + inp: [G; IN_619], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_620], 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]; @@ -50890,13 +52926,14 @@ fn aiur_fn_620( let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_620] = [__v_0]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_0]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -50930,60 +52967,60 @@ fn aiur_fn_620( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __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_720] = { let __args: [G; IN_720] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __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_329] = { let __args: [G; IN_329] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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_611] = { let __args: [G; IN_611] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __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_611] = { let __args: [G; IN_611] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __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_611] = { let __args: [G; IN_611] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); - let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; @@ -50993,24 +53030,25 @@ fn aiur_fn_620( let __v_95: G = (__v_94 + __v_64); let __v_96: G = G::from_u64(0); let __v_97: G = G::from_u64(0); - let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); - let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_110]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_110]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51020,15 +53058,15 @@ fn aiur_fn_620( }) } -const INPUT_SIZE_621: usize = 13; -const IN_621: usize = 13; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_620: usize = 13; +const IN_620: usize = 13; +const OUT_620: usize = 1; +fn aiur_fn_620( + inp: [G; IN_620], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_621], 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]; @@ -51043,32 +53081,32 @@ fn aiur_fn_621( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __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_632] = { let __args: [G; IN_632] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -51080,28 +53118,29 @@ fn aiur_fn_621( let __v_42: G = (__v_39 - __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_621] = [__v_49]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_620] = [__v_49]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_622: usize = 3; -const IN_622: usize = 3; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_621: usize = 3; +const IN_621: usize = 3; +const OUT_621: usize = 1; +fn aiur_fn_621( + inp: [G; IN_621], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_622], 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]; @@ -51117,20 +53156,22 @@ fn aiur_fn_622( 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_622] = [__v_11]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_621] = [__v_11]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_622] = [__v_12]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_621] = [__v_12]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51140,15 +53181,15 @@ 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_622: usize = 5; +const IN_622: usize = 5; +const OUT_622: usize = 1; +fn aiur_fn_622( + inp: [G; IN_622], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_623], 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]; @@ -51209,15 +53250,17 @@ fn aiur_fn_623( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_623] = [__v_54]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_622] = [__v_54]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_623] = [__v_4]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_622] = [__v_4]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51226,15 +53269,15 @@ fn aiur_fn_623( }) } -const INPUT_SIZE_624: usize = 8; -const IN_624: usize = 8; -const OUT_624: usize = 1; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_623: usize = 8; +const IN_623: usize = 8; +const OUT_623: usize = 1; +fn aiur_fn_623( + inp: [G; IN_623], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], 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]; @@ -51294,8 +53337,9 @@ fn aiur_fn_624( let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_624] = [__v_6]; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_6]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51320,7 +53364,7 @@ fn aiur_fn_624( 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_577] = { let __args: [G; IN_577] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; @@ -51358,9 +53402,9 @@ fn aiur_fn_624( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -51381,17 +53425,19 @@ fn aiur_fn_624( let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_624] = [__v_55]; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_55]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = (__v_7 + __v_70); - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __ret: [G; OUT_624] = [__v_72]; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_72]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51399,10 +53445,11 @@ fn aiur_fn_624( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_624] = [__v_57]; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_57]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51414,15 +53461,15 @@ fn aiur_fn_624( }) } -const INPUT_SIZE_625: usize = 1; -const IN_625: usize = 1; -const OUT_625: usize = 1; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_624: usize = 1; +const IN_624: usize = 1; +const OUT_624: usize = 1; +fn aiur_fn_624( + inp: [G; IN_624], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_625], ExecError> { +) -> Result<[G; OUT_624], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -51436,9 +53483,10 @@ fn aiur_fn_625( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_625] = [__v_9]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_624] = [__v_9]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51469,11 +53517,12 @@ fn aiur_fn_625( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_625] = [__v_23]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_624] = [__v_23]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51483,15 +53532,15 @@ fn aiur_fn_625( }) } -const INPUT_SIZE_626: usize = 3; -const IN_626: usize = 3; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_625: usize = 3; +const IN_625: usize = 3; +const OUT_625: usize = 1; +fn aiur_fn_625( + inp: [G; IN_625], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_626], 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]; @@ -51518,35 +53567,36 @@ fn aiur_fn_626( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_626] = [__v_34]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_34]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_627: usize = 15; -const IN_627: usize = 15; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_626: usize = 15; +const IN_626: usize = 15; +const OUT_626: usize = 1; +fn aiur_fn_626( + inp: [G; IN_626], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_627], 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]; @@ -51568,9 +53618,10 @@ fn aiur_fn_627( 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_627] = [__v_18]; - record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_626] = [__v_18]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51591,20 +53642,21 @@ fn aiur_fn_627( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __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_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_627] = [__v_37]; - record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_626] = [__v_37]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51616,15 +53668,15 @@ fn aiur_fn_627( }) } -const INPUT_SIZE_628: usize = 5; -const IN_628: usize = 5; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_627: usize = 5; +const IN_627: usize = 5; +const OUT_627: usize = 1; +fn aiur_fn_627( + inp: [G; IN_627], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_628], ExecError> { +) -> Result<[G; OUT_627], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51633,23 +53685,24 @@ fn aiur_fn_628( let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_7]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_627] = [__v_7]; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_629: usize = 8; -const IN_629: usize = 8; -const OUT_629: usize = 1; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_628: usize = 8; +const IN_628: usize = 8; +const OUT_628: usize = 1; +fn aiur_fn_628( + inp: [G; IN_628], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_629], 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]; @@ -51670,9 +53723,10 @@ fn aiur_fn_629( 1u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_16]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_628] = [__v_16]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51694,28 +53748,30 @@ fn aiur_fn_629( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_629] = { let __args: [G; IN_629] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_34]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_34]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_29]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_29]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51727,15 +53783,15 @@ fn aiur_fn_629( }) } -const INPUT_SIZE_630: usize = 5; -const IN_630: usize = 5; -const OUT_630: usize = 1; -fn aiur_fn_630( - inp: [G; IN_630], +const INPUT_SIZE_629: usize = 5; +const IN_629: usize = 5; +const OUT_629: usize = 1; +fn aiur_fn_629( + inp: [G; IN_629], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_630], 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]; @@ -51749,24 +53805,26 @@ fn aiur_fn_630( let __v_7: G = (__v_1 - __v_6); let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_630] = [__v_10]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_629] = [__v_10]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_9]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_9]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51775,9 +53833,10 @@ fn aiur_fn_630( let __v_9: G = (__v_1 - __v_8); let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_630] = [__v_12]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_629] = [__v_12]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51786,15 +53845,15 @@ 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_630: usize = 2; +const IN_630: usize = 2; +const OUT_630: usize = 1; +fn aiur_fn_630( + inp: [G; IN_630], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_631], 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]; @@ -51807,30 +53866,32 @@ fn aiur_fn_631( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_8]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_8]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_631] = [__v_1]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_1]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_632: usize = 7; -const IN_632: usize = 7; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_631: usize = 7; +const IN_631: usize = 7; +const OUT_631: usize = 1; +fn aiur_fn_631( + inp: [G; IN_631], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_632], 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]; @@ -51841,8 +53902,9 @@ fn aiur_fn_632( let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_632] = [__v_0]; - record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_0]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51853,26 +53915,27 @@ fn aiur_fn_632( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_632] = { let __args: [G; IN_632] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_632] = [__v_18]; - record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_18]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -51881,19 +53944,20 @@ fn aiur_fn_632( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_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_632] = { let __args: [G; IN_632] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_632] = [__v_26]; - record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_26]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51907,15 +53971,15 @@ fn aiur_fn_632( }) } -const INPUT_SIZE_633: usize = 13; -const IN_633: usize = 13; -const OUT_633: usize = 1; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_632: usize = 13; +const IN_632: usize = 13; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_633], 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]; @@ -51930,42 +53994,42 @@ fn aiur_fn_633( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_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_632] = { let __args: [G; IN_632] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_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_718] = { let __args: [G; IN_718] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_107] = { let __args: [G; IN_107] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -51973,67 +54037,69 @@ fn aiur_fn_633( let __v_45: G = (__v_43 - __v_44); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_62]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_632] = [__v_62]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_634: usize = 1; -const IN_634: usize = 1; -const OUT_634: usize = 2; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_633: usize = 1; +const IN_633: usize = 1; +const OUT_633: usize = 2; +fn aiur_fn_633( + inp: [G; IN_633], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_634], ExecError> { +) -> Result<[G; OUT_633], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_634] = [__v_6, __v_5]; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_6, __v_5]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_635: usize = 2; -const IN_635: usize = 2; -const OUT_635: usize = 2; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_634: usize = 2; +const IN_634: usize = 2; +const OUT_634: usize = 2; +fn aiur_fn_634( + inp: [G; IN_634], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_635], 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]; @@ -52045,32 +54111,34 @@ fn aiur_fn_635( match __v_2.as_canonical_u64() { 5u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_635] = [__v_8, __v_9]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_634] = [__v_8, __v_9]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_635] = [__v_1, __v_0]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_634] = [__v_1, __v_0]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_636: usize = 8; -const IN_636: usize = 8; -const OUT_636: usize = 1; -fn aiur_fn_636( - inp: [G; IN_636], +const INPUT_SIZE_635: usize = 8; +const IN_635: usize = 8; +const OUT_635: usize = 1; +fn aiur_fn_635( + inp: [G; IN_635], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], 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]; @@ -52088,31 +54156,32 @@ fn aiur_fn_636( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_636] = [__v_13]; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_635] = [__v_13]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __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_720] = { let __args: [G; IN_720] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __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_329] = { let __args: [G; IN_329] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -52125,38 +54194,39 @@ fn aiur_fn_636( let __v_33: G = (__v_31 - __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_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_636] = { let __args: [G; IN_636] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_636] = [__v_58]; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_635] = [__v_58]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52166,15 +54236,15 @@ 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_636: usize = 3; +const IN_636: usize = 3; +const OUT_636: usize = 1; +fn aiur_fn_636( + inp: [G; IN_636], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_637], 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]; @@ -52187,20 +54257,22 @@ fn aiur_fn_637( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_637] = [__v_8]; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_636] = [__v_8]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_637] = [__v_9]; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_636] = [__v_9]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52210,15 +54282,15 @@ fn aiur_fn_637( }) } -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_637: usize = 4; +const IN_637: usize = 4; +const OUT_637: usize = 1; +fn aiur_fn_637( + inp: [G; IN_637], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], 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]; @@ -52227,8 +54299,9 @@ fn aiur_fn_638( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_638] = [__v_0]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_637] = [__v_0]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52237,31 +54310,32 @@ fn aiur_fn_638( let __v_7: G = (__v_2 - __v_6); let __v_8: G = (__v_7 - __v_3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_638] = [__v_16]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_637] = [__v_16]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_639: usize = 6; -const IN_639: usize = 6; -const OUT_639: usize = 1; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_638: usize = 6; +const IN_638: usize = 6; +const OUT_638: usize = 1; +fn aiur_fn_638( + inp: [G; IN_638], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_639], 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]; @@ -52274,63 +54348,66 @@ fn aiur_fn_639( 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_611] = { let __args: [G; IN_611] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_9]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_9]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_7]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_7]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -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_639: usize = 3; +const IN_639: usize = 3; +const OUT_639: usize = 2; +fn aiur_fn_639( + inp: [G; IN_639], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_640], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_640] = [__v_3, __v_4]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = [__v_3, __v_4]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_641: usize = 3; -const IN_641: usize = 3; -const OUT_641: usize = 2; -fn aiur_fn_641( - inp: [G; IN_641], +const INPUT_SIZE_640: usize = 3; +const IN_640: usize = 3; +const OUT_640: usize = 2; +fn aiur_fn_640( + inp: [G; IN_640], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_641], 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 = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -52339,11 +54416,12 @@ fn aiur_fn_641( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_641] = [__v_11, __v_12]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = [__v_11, __v_12]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52358,18 +54436,20 @@ fn aiur_fn_641( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_641] = [__v_18, __v_19]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = [__v_18, __v_19]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_641] = [__v_17, __v_18]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = [__v_17, __v_18]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52378,15 +54458,15 @@ fn aiur_fn_641( }) } -const INPUT_SIZE_642: usize = 5; -const IN_642: usize = 5; -const OUT_642: usize = 2; -fn aiur_fn_642( - inp: [G; IN_642], +const INPUT_SIZE_641: usize = 5; +const IN_641: usize = 5; +const OUT_641: usize = 2; +fn aiur_fn_641( + inp: [G; IN_641], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_642], 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]; @@ -52404,8 +54484,9 @@ fn aiur_fn_642( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_642] = [__v_11, __v_12]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_11, __v_12]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52417,7 +54498,7 @@ fn aiur_fn_642( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -52428,18 +54509,20 @@ fn aiur_fn_642( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_642] = [__v_14, __v_4]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_14, __v_4]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_4 + __v_14); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_642] = [__v_16, __v_17]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_16, __v_17]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52451,15 +54534,15 @@ fn aiur_fn_642( }) } -const INPUT_SIZE_643: usize = 3; -const IN_643: usize = 3; -const OUT_643: usize = 1; -fn aiur_fn_643( - inp: [G; IN_643], +const INPUT_SIZE_642: usize = 3; +const IN_642: usize = 3; +const OUT_642: usize = 1; +fn aiur_fn_642( + inp: [G; IN_642], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_643], 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]; @@ -52471,8 +54554,9 @@ fn aiur_fn_643( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_643] = [__v_6]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_6]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52483,28 +54567,31 @@ fn aiur_fn_643( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_643] = [__v_9]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_9]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_12]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_12]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_643] = [__v_12]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_12]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52521,15 +54608,15 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 7; -const IN_644: usize = 7; -const OUT_644: usize = 4; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_643: usize = 7; +const IN_643: usize = 7; +const OUT_643: usize = 4; +fn aiur_fn_643( + inp: [G; IN_643], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_644], 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]; @@ -52546,66 +54633,69 @@ fn aiur_fn_644( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; match __v_12.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_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_644] = [__v_22, __v_23, __v_24, __v_25]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_22, __v_23, __v_24, __v_25]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_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_644] = [__v_18, __v_19, __v_20, __v_21]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_18, __v_19, __v_20, __v_21]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_11, __v_12, __v_13, __v_0]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_11, __v_12, __v_13, __v_0]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_645: usize = 4; -const IN_645: usize = 4; -const OUT_645: usize = 1; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_644: usize = 4; +const IN_644: usize = 4; +const OUT_644: usize = 1; +fn aiur_fn_644( + inp: [G; IN_644], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_645], 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]; @@ -52622,9 +54712,10 @@ fn aiur_fn_645( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_12]; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_644] = [__v_12]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52645,26 +54736,28 @@ fn aiur_fn_645( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_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_645] = { let __args: [G; IN_645] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_30]; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_644] = [__v_30]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_645] = [__v_23]; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_23]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52676,15 +54769,15 @@ fn aiur_fn_645( }) } -const INPUT_SIZE_646: usize = 13; -const IN_646: usize = 13; -const OUT_646: usize = 0; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_645: usize = 13; +const IN_645: usize = 13; +const OUT_645: usize = 0; +fn aiur_fn_645( + inp: [G; IN_645], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_646], 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]; @@ -52701,7 +54794,7 @@ fn aiur_fn_646( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -52720,9 +54813,9 @@ fn aiur_fn_646( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -52735,11 +54828,11 @@ fn aiur_fn_646( 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_540] = { let __args: [G; IN_540] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __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_649] = { let __args: [G; IN_649] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -52752,15 +54845,15 @@ fn aiur_fn_646( 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_647] = { let __args: [G; IN_647] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __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()) }); @@ -52768,9 +54861,10 @@ fn aiur_fn_646( 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_615] = { let __args: [G; IN_615] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_646] = []; - record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_645] = []; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52785,15 +54879,15 @@ fn aiur_fn_646( }) } -const INPUT_SIZE_647: usize = 6; -const IN_647: usize = 6; -const OUT_647: usize = 0; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_646: usize = 6; +const IN_646: usize = 6; +const OUT_646: usize = 0; +fn aiur_fn_646( + inp: [G; IN_646], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], 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]; @@ -52804,7 +54898,7 @@ fn aiur_fn_647( 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_540] = { let __args: [G; IN_540] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -52816,13 +54910,14 @@ fn aiur_fn_647( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52832,15 +54927,15 @@ fn aiur_fn_647( }) } -const INPUT_SIZE_648: usize = 2; -const IN_648: usize = 2; -const OUT_648: usize = 1; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_647: usize = 2; +const IN_647: usize = 2; +const OUT_647: usize = 1; +fn aiur_fn_647( + inp: [G; IN_647], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_648], 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]; @@ -52849,38 +54944,40 @@ fn aiur_fn_648( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_648] = [__v_5]; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_647] = [__v_5]; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_648] = [__v_10]; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_647] = [__v_10]; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_649: usize = 3; -const IN_649: usize = 3; -const OUT_649: usize = 0; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_648: usize = 3; +const IN_648: usize = 3; +const OUT_648: usize = 0; +fn aiur_fn_648( + inp: [G; IN_648], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_649], 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]; @@ -52893,18 +54990,20 @@ fn aiur_fn_649( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_649] = []; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_649] = []; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52916,15 +55015,15 @@ fn aiur_fn_649( }) } -const INPUT_SIZE_650: usize = 4; -const IN_650: usize = 4; -const OUT_650: usize = 3; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_649: usize = 4; +const IN_649: usize = 4; +const OUT_649: usize = 3; +fn aiur_fn_649( + inp: [G; IN_649], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_650], 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]; @@ -52932,8 +55031,9 @@ fn aiur_fn_650( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_650] = [__v_0, __v_2, __v_3]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_0, __v_2, __v_3]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52949,18 +55049,20 @@ fn aiur_fn_650( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __ret: [G; OUT_650] = [__v_14, __v_15, __v_16]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_14, __v_15, __v_16]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_650] = [__v_0, __v_2, __v_3]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_0, __v_2, __v_3]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52969,15 +55071,15 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 13; -const IN_651: usize = 13; -const OUT_651: usize = 0; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_650: usize = 13; +const IN_650: usize = 13; +const OUT_650: usize = 0; +fn aiur_fn_650( + inp: [G; IN_650], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_651], 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]; @@ -52992,58 +55094,60 @@ fn aiur_fn_651( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __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_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -53051,72 +55155,76 @@ fn aiur_fn_651( } let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -53133,24 +55241,25 @@ fn aiur_fn_651( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; 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()) }); } let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53160,17 +55269,18 @@ fn aiur_fn_651( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53180,15 +55290,15 @@ fn aiur_fn_651( }) } -const INPUT_SIZE_652: usize = 1; -const IN_652: usize = 1; -const OUT_652: usize = 0; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_651: usize = 1; +const IN_651: usize = 1; +const OUT_651: usize = 0; +fn aiur_fn_651( + inp: [G; IN_651], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_652], ExecError> { +) -> Result<[G; OUT_651], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; @@ -53206,22 +55316,23 @@ fn aiur_fn_652( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_652] = []; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_653: usize = 1; -const IN_653: usize = 1; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_652: usize = 1; +const IN_652: usize = 1; +const OUT_652: usize = 1; +fn aiur_fn_652( + inp: [G; IN_652], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], ExecError> { +) -> Result<[G; OUT_652], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -53250,92 +55361,99 @@ fn aiur_fn_653( let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_653] = [__v_24]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_652] = [__v_24]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_653] = [__v_22]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_652] = [__v_22]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_21]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_21]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_21]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_21]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_21]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_21]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_23]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_23]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_653] = [__v_21]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_652] = [__v_21]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_654: usize = 1; -const IN_654: usize = 1; -const OUT_654: usize = 1; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_653: usize = 1; +const IN_653: usize = 1; +const OUT_653: usize = 1; +fn aiur_fn_653( + inp: [G; IN_653], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_654], ExecError> { +) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -53346,20 +55464,22 @@ fn aiur_fn_654( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_654] = [__v_6]; - record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_653] = [__v_6]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_654] = [__v_6]; - record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_6]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53369,15 +55489,15 @@ fn aiur_fn_654( }) } -const INPUT_SIZE_655: usize = 1; -const IN_655: usize = 1; -const OUT_655: usize = 1; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_654: usize = 1; +const IN_654: usize = 1; +const OUT_654: usize = 1; +fn aiur_fn_654( + inp: [G; IN_654], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_655], ExecError> { +) -> Result<[G; OUT_654], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -53396,22 +55516,24 @@ fn aiur_fn_655( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_655] = [__v_14]; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_654] = [__v_14]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_655] = [__v_14]; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_14]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53423,15 +55545,15 @@ fn aiur_fn_655( }) } -const INPUT_SIZE_656: usize = 1; -const IN_656: usize = 1; -const OUT_656: usize = 1; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_655: usize = 1; +const IN_655: usize = 1; +const OUT_655: usize = 1; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_656], ExecError> { +) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -53475,22 +55597,24 @@ fn aiur_fn_656( 1u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_656] = [__v_39]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_655] = [__v_39]; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_39]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_655] = [__v_39]; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53502,15 +55626,15 @@ fn aiur_fn_656( }) } -const INPUT_SIZE_657: usize = 1; -const IN_657: usize = 1; -const OUT_657: usize = 1; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_656: usize = 1; +const IN_656: usize = 1; +const OUT_656: usize = 1; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_657], ExecError> { +) -> Result<[G; OUT_656], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -53565,9 +55689,10 @@ fn aiur_fn_657( 1u64 => { let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_657] = [__v_50]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_656] = [__v_50]; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -53575,18 +55700,19 @@ fn aiur_fn_657( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_52]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = [__v_52]; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53594,18 +55720,19 @@ fn aiur_fn_657( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_52]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = [__v_52]; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53613,18 +55740,19 @@ fn aiur_fn_657( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_52]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = [__v_52]; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53641,15 +55769,15 @@ fn aiur_fn_657( }) } -const INPUT_SIZE_658: usize = 48; -const IN_658: usize = 48; -const OUT_658: usize = 1; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_657: usize = 48; +const IN_657: usize = 48; +const OUT_657: usize = 1; +fn aiur_fn_657( + inp: [G; IN_657], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_658], 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]; @@ -53701,22 +55829,23 @@ fn aiur_fn_658( let __v_47: G = inp[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_658] = [__v_52]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_52]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53724,16 +55853,17 @@ fn aiur_fn_658( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_658] = [__v_52]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_52]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53741,12 +55871,13 @@ fn aiur_fn_658( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_658] = [__v_50]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_50]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53754,28 +55885,31 @@ fn aiur_fn_658( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_658] = [__v_50]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_50]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_658] = [__v_50]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_50]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_658] = [__v_48]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_48]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53784,15 +55918,15 @@ fn aiur_fn_658( }) } -const INPUT_SIZE_659: usize = 2; -const IN_659: usize = 2; -const OUT_659: usize = 1; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_658: usize = 2; +const IN_658: usize = 2; +const OUT_658: usize = 1; +fn aiur_fn_658( + inp: [G; IN_658], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], 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]; @@ -53803,8 +55937,9 @@ fn aiur_fn_659( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_659] = [__v_5]; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_5]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -53812,15 +55947,17 @@ fn aiur_fn_659( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_659] = [__v_6]; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_6]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_6]; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_6]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53832,15 +55969,15 @@ fn aiur_fn_659( }) } -const INPUT_SIZE_660: usize = 1; -const IN_660: usize = 1; -const OUT_660: usize = 0; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_659: usize = 1; +const IN_659: usize = 1; +const OUT_659: usize = 0; +fn aiur_fn_659( + inp: [G; IN_659], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_660], ExecError> { +) -> Result<[G; OUT_659], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; @@ -53897,14 +56034,14 @@ fn aiur_fn_660( 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_662] = { let __args: [G; IN_662] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -53912,8 +56049,8 @@ fn aiur_fn_660( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -53921,8 +56058,8 @@ fn aiur_fn_660( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -53930,39 +56067,40 @@ fn aiur_fn_660( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_660] = []; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_661: usize = 3; -const IN_661: usize = 3; -const OUT_661: usize = 0; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_660: usize = 3; +const IN_660: usize = 3; +const OUT_660: usize = 0; +fn aiur_fn_660( + inp: [G; IN_660], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_661], 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]; @@ -53973,16 +56111,17 @@ fn aiur_fn_661( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_661] = []; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_660] = []; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __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_660] = { let __args: [G; IN_660] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -53992,9 +56131,10 @@ fn aiur_fn_661( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_660] = []; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54004,15 +56144,15 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 4; -const IN_662: usize = 4; -const OUT_662: usize = 0; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_661: usize = 4; +const IN_661: usize = 4; +const OUT_661: usize = 0; +fn aiur_fn_661( + inp: [G; IN_661], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], 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]; @@ -54068,17 +56208,19 @@ fn aiur_fn_662( let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_662] = []; - record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_661] = []; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_662] = []; - record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54088,15 +56230,15 @@ fn aiur_fn_662( }) } -const INPUT_SIZE_663: usize = 48; -const IN_663: usize = 48; -const OUT_663: usize = 0; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_662: usize = 48; +const IN_662: usize = 48; +const OUT_662: usize = 0; +fn aiur_fn_662( + inp: [G; IN_662], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], 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]; @@ -54163,79 +56305,82 @@ fn aiur_fn_663( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_663] = []; - record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_664: usize = 1; -const IN_664: usize = 1; -const OUT_664: usize = 1; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_663: usize = 1; +const IN_663: usize = 1; +const OUT_663: usize = 1; +fn aiur_fn_663( + inp: [G; IN_663], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], ExecError> { +) -> Result<[G; OUT_663], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_664] = [__v_8]; - record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_663] = [__v_8]; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_665: usize = 2; -const IN_665: usize = 2; -const OUT_665: usize = 1; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_664: usize = 2; +const IN_664: usize = 2; +const OUT_664: usize = 1; +fn aiur_fn_664( + inp: [G; IN_664], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], 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 __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_665] = [__v_10]; - record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_664] = [__v_10]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_666: usize = 1; -const IN_666: usize = 1; -const OUT_666: usize = 3; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_665: usize = 1; +const IN_665: usize = 1; +const OUT_665: usize = 3; +fn aiur_fn_665( + inp: [G; IN_665], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], ExecError> { +) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -54246,15 +56391,16 @@ fn aiur_fn_666( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_666] = [__v_5, __v_10, __v_4]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_665] = [__v_5, __v_10, __v_4]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -54290,29 +56436,31 @@ fn aiur_fn_666( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_666] = [__v_35, __v_38, __v_2]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_665] = [__v_35, __v_38, __v_2]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __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_666] = { let __args: [G; IN_666] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __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_665] = { let __args: [G; IN_665] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_666] = [__v_9, __v_10, __v_8]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_665] = [__v_9, __v_10, __v_8]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54322,15 +56470,15 @@ fn aiur_fn_666( }) } -const INPUT_SIZE_667: usize = 1; -const IN_667: usize = 1; -const OUT_667: usize = 1; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_666: usize = 1; +const IN_666: usize = 1; +const OUT_666: usize = 1; +fn aiur_fn_666( + inp: [G; IN_666], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], ExecError> { +) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -54384,7 +56532,7 @@ fn aiur_fn_667( 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_666] = { let __args: [G; IN_666] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -54540,21 +56688,22 @@ fn aiur_fn_667( 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_667] = [__v_49]; - record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_666] = [__v_49]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_668: usize = 7; -const IN_668: usize = 7; -const OUT_668: usize = 6; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_667: usize = 7; +const IN_667: usize = 7; +const OUT_667: usize = 6; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_668], 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]; @@ -54569,28 +56718,30 @@ fn aiur_fn_668( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_668] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_667] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __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_668] = { let __args: [G; IN_668] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __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_668] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_667] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54600,15 +56751,15 @@ fn aiur_fn_668( }) } -const INPUT_SIZE_669: usize = 7; -const IN_669: usize = 7; -const OUT_669: usize = 1; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_668: usize = 7; +const IN_668: usize = 7; +const OUT_668: usize = 1; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], 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]; @@ -54618,23 +56769,24 @@ fn aiur_fn_669( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_669] = [__v_8]; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_8]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_670: usize = 14; -const IN_670: usize = 14; -const OUT_670: usize = 0; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_669: usize = 14; +const IN_669: usize = 14; +const OUT_669: usize = 0; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], 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]; @@ -54650,18 +56802,19 @@ fn aiur_fn_670( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = []; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = []; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -54728,14 +56881,14 @@ fn aiur_fn_670( 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_662] = { let __args: [G; IN_662] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -54743,8 +56896,8 @@ fn aiur_fn_670( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -54752,8 +56905,8 @@ fn aiur_fn_670( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -54761,24 +56914,25 @@ fn aiur_fn_670( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_670] = []; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_669] = []; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54787,15 +56941,15 @@ fn aiur_fn_670( }) } -const INPUT_SIZE_671: usize = 16; -const IN_671: usize = 16; -const OUT_671: usize = 0; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_670: usize = 16; +const IN_670: usize = 16; +const OUT_670: usize = 0; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], 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]; @@ -54819,16 +56973,17 @@ fn aiur_fn_671( let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_671] = []; - record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_670] = []; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __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_670] = { let __args: [G; IN_670] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -54838,9 +56993,10 @@ fn aiur_fn_671( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_670] = []; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54850,15 +57006,15 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 13; -const IN_672: usize = 13; -const OUT_672: usize = 0; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_671: usize = 13; +const IN_671: usize = 13; +const OUT_671: usize = 0; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], 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]; @@ -54879,16 +57035,18 @@ fn aiur_fn_672( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_672] = []; - record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = []; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_672] = []; - record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_671] = []; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54898,30 +57056,30 @@ fn aiur_fn_672( }) } -const INPUT_SIZE_673: usize = 3; -const IN_673: usize = 3; -const OUT_673: usize = 0; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_672: usize = 3; +const IN_672: usize = 3; +const OUT_672: usize = 0; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], 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 __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -54933,7 +57091,7 @@ fn aiur_fn_673( 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_668] = { let __args: [G; IN_668] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -54942,29 +57100,30 @@ fn aiur_fn_673( 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_668] = { let __args: [G; IN_668] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __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_672] = { let __args: [G; IN_672] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_673] = []; - record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_672] = []; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_674: usize = 1; -const IN_674: usize = 1; -const OUT_674: usize = 3; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_673: usize = 1; +const IN_673: usize = 1; +const OUT_673: usize = 3; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], ExecError> { +) -> Result<[G; OUT_673], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -54974,8 +57133,9 @@ fn aiur_fn_674( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_674] = [__v_3, __v_4, __v_2]; - record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_673] = [__v_3, __v_4, __v_2]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -54983,8 +57143,9 @@ fn aiur_fn_674( 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_674] = [__v_5, __v_3, __v_4]; - record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_673] = [__v_5, __v_3, __v_4]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54994,15 +57155,15 @@ fn aiur_fn_674( }) } -const INPUT_SIZE_675: usize = 2; -const IN_675: usize = 2; -const OUT_675: usize = 10; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_674: usize = 2; +const IN_674: usize = 2; +const OUT_674: usize = 10; +fn aiur_fn_674( + inp: [G; IN_674], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], 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]; @@ -55010,8 +57171,9 @@ fn aiur_fn_675( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_675] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55026,23 +57188,24 @@ fn aiur_fn_675( 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_675] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_676: usize = 2; -const IN_676: usize = 2; -const OUT_676: usize = 3; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_675: usize = 2; +const IN_675: usize = 2; +const OUT_675: usize = 3; +fn aiur_fn_675( + inp: [G; IN_675], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], 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]; @@ -55050,8 +57213,9 @@ fn aiur_fn_676( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_676] = [__v_2, __v_3, __v_1]; - record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_675] = [__v_2, __v_3, __v_1]; + record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55059,23 +57223,24 @@ fn aiur_fn_676( 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_676] = [__v_4, __v_2, __v_3]; - record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_675] = [__v_4, __v_2, __v_3]; + record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_677: usize = 2; -const IN_677: usize = 2; -const OUT_677: usize = 3; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_676: usize = 2; +const IN_676: usize = 2; +const OUT_676: usize = 3; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], 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]; @@ -55083,8 +57248,9 @@ fn aiur_fn_677( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_677] = [__v_2, __v_3, __v_1]; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__v_2, __v_3, __v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55092,23 +57258,24 @@ fn aiur_fn_677( 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_677] = [__v_4, __v_2, __v_3]; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__v_4, __v_2, __v_3]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_678: usize = 2; -const IN_678: usize = 2; -const OUT_678: usize = 3; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_677: usize = 2; +const IN_677: usize = 2; +const OUT_677: usize = 3; +fn aiur_fn_677( + inp: [G; IN_677], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], ExecError> { +) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55116,8 +57283,9 @@ fn aiur_fn_678( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_678] = [__v_2, __v_3, __v_1]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_2, __v_3, __v_1]; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55128,22 +57296,25 @@ fn aiur_fn_678( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55155,15 +57326,15 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 2; -const IN_679: usize = 2; -const OUT_679: usize = 3; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_678: usize = 2; +const IN_678: usize = 2; +const OUT_678: usize = 3; +fn aiur_fn_678( + inp: [G; IN_678], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], 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]; @@ -55171,8 +57342,9 @@ fn aiur_fn_679( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_679] = [__v_2, __v_3, __v_1]; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_2, __v_3, __v_1]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55183,29 +57355,33 @@ fn aiur_fn_679( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); - let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55217,15 +57393,15 @@ fn aiur_fn_679( }) } -const INPUT_SIZE_680: usize = 9; -const IN_680: usize = 9; -const OUT_680: usize = 2; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_679: usize = 9; +const IN_679: usize = 9; +const OUT_679: usize = 2; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], 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]; @@ -55242,9 +57418,10 @@ fn aiur_fn_680( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_680] = [__v_12, __v_0]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_679] = [__v_12, __v_0]; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55276,28 +57453,29 @@ fn aiur_fn_680( 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_680] = { let __args: [G; IN_680] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_680] = [__v_39, __v_37]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_679] = [__v_39, __v_37]; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_681: usize = 2; -const IN_681: usize = 2; -const OUT_681: usize = 3; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_680: usize = 2; +const IN_680: usize = 2; +const OUT_680: usize = 3; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_681], 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]; @@ -55305,8 +57483,9 @@ fn aiur_fn_681( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_681] = [__v_2, __v_3, __v_1]; - record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_2, __v_3, __v_1]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55320,27 +57499,28 @@ fn aiur_fn_681( 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_680] = { let __args: [G; IN_680] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __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_681] = [__v_13, __v_11, __v_12]; - record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_13, __v_11, __v_12]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_682: usize = 1; -const IN_682: usize = 1; -const OUT_682: usize = 41; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_681: usize = 1; +const IN_681: usize = 1; +const OUT_681: usize = 41; +fn aiur_fn_681( + inp: [G; IN_681], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], ExecError> { +) -> Result<[G; OUT_681], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; @@ -55362,11 +57542,11 @@ fn aiur_fn_682( 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_677] = { let __args: [G; IN_677] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -55377,7 +57557,7 @@ fn aiur_fn_682( 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_675] = { let __args: [G; IN_675] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -55388,7 +57568,7 @@ fn aiur_fn_682( 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_675] = { let __args: [G; IN_675] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -55399,7 +57579,7 @@ fn aiur_fn_682( 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_675] = { let __args: [G; IN_675] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -55410,25 +57590,26 @@ fn aiur_fn_682( 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_676] = { let __args: [G; IN_676] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_681] = [__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[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_683: usize = 1; -const IN_683: usize = 1; -const OUT_683: usize = 49; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_682: usize = 1; +const IN_682: usize = 1; +const OUT_682: usize = 49; +fn aiur_fn_682( + inp: [G; IN_682], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], ExecError> { +) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; @@ -55441,7 +57622,7 @@ fn aiur_fn_683( 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_682] = { let __args: [G; IN_682] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -55483,21 +57664,22 @@ fn aiur_fn_683( 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_683] = [__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[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_684: usize = 9; -const IN_684: usize = 9; -const OUT_684: usize = 2; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_683: usize = 9; +const IN_683: usize = 9; +const OUT_683: usize = 2; +fn aiur_fn_683( + inp: [G; IN_683], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], 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]; @@ -55514,13 +57696,14 @@ fn aiur_fn_684( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_684] = [__v_12, __v_0]; - record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_683] = [__v_12, __v_0]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -55579,28 +57762,29 @@ fn aiur_fn_684( 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_684] = { let __args: [G; IN_684] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); - let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_684] = [__v_70, __v_68]; - record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_683] = [__v_70, __v_68]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_685: usize = 2; -const IN_685: usize = 2; -const OUT_685: usize = 3; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_684: usize = 2; +const IN_684: usize = 2; +const OUT_684: usize = 3; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], 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]; @@ -55608,8 +57792,9 @@ fn aiur_fn_685( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_685] = [__v_2, __v_3, __v_1]; - record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_684] = [__v_2, __v_3, __v_1]; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55623,27 +57808,28 @@ fn aiur_fn_685( 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_684] = { let __args: [G; IN_684] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __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_685] = [__v_13, __v_11, __v_12]; - record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_684] = [__v_13, __v_11, __v_12]; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_686: usize = 1; -const IN_686: usize = 1; -const OUT_686: usize = 55; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_685: usize = 1; +const IN_685: usize = 1; +const OUT_685: usize = 55; +fn aiur_fn_685( + inp: [G; IN_685], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_685], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -55679,15 +57865,15 @@ fn aiur_fn_686( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -55698,26 +57884,27 @@ fn aiur_fn_686( 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_676] = { let __args: [G; IN_676] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_676] = { let __args: [G; IN_676] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -55728,7 +57915,7 @@ fn aiur_fn_686( 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_675] = { let __args: [G; IN_675] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -55739,7 +57926,7 @@ fn aiur_fn_686( 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_675] = { let __args: [G; IN_675] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -55750,30 +57937,31 @@ fn aiur_fn_686( 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_676] = { let __args: [G; IN_676] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_685] = { let __args: [G; IN_685] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __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_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -55784,7 +57972,7 @@ fn aiur_fn_686( 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_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -55795,7 +57983,7 @@ fn aiur_fn_686( 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_675] = { let __args: [G; IN_675] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -55806,7 +57994,7 @@ fn aiur_fn_686( 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_675] = { let __args: [G; IN_675] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -55817,7 +58005,7 @@ fn aiur_fn_686( 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_675] = { let __args: [G; IN_675] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -55828,17 +58016,18 @@ fn aiur_fn_686( 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_676] = { let __args: [G; IN_676] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_681] = { let __args: [G; IN_681] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __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_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55848,15 +58037,15 @@ fn aiur_fn_686( }) } -const INPUT_SIZE_687: usize = 1; -const IN_687: usize = 1; -const OUT_687: usize = 63; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_686: usize = 1; +const IN_686: usize = 1; +const OUT_686: usize = 63; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], ExecError> { +) -> Result<[G; OUT_686], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; @@ -55869,7 +58058,7 @@ fn aiur_fn_687( 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_686] = { let __args: [G; IN_686] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -55925,21 +58114,22 @@ fn aiur_fn_687( 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_687] = [__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[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_688: usize = 9; -const IN_688: usize = 9; -const OUT_688: usize = 2; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_687: usize = 9; +const IN_687: usize = 9; +const OUT_687: usize = 2; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_688], 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]; @@ -55956,13 +58146,14 @@ fn aiur_fn_688( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_688] = [__v_12, __v_0]; - record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_687] = [__v_12, __v_0]; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -56035,28 +58226,29 @@ fn aiur_fn_688( 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_688] = { let __args: [G; IN_688] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); - let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_688] = [__v_84, __v_82]; - record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!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 __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_687] = [__v_84, __v_82]; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_689: usize = 1; -const IN_689: usize = 1; -const OUT_689: usize = 55; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_688: usize = 1; +const IN_688: usize = 1; +const OUT_688: usize = 55; +fn aiur_fn_688( + inp: [G; IN_688], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_689], ExecError> { +) -> Result<[G; OUT_688], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -56092,15 +58284,15 @@ fn aiur_fn_689( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56111,30 +58303,31 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_676] = { let __args: [G; IN_676] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56145,7 +58338,7 @@ fn aiur_fn_689( 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_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -56156,7 +58349,7 @@ fn aiur_fn_689( 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_675] = { let __args: [G; IN_675] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -56167,7 +58360,7 @@ fn aiur_fn_689( 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_675] = { let __args: [G; IN_675] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -56178,7 +58371,7 @@ fn aiur_fn_689( 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_675] = { let __args: [G; IN_675] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -56189,25 +58382,26 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_681] = { let __args: [G; IN_681] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -56218,22 +58412,23 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -56244,18 +58439,19 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56266,7 +58462,7 @@ fn aiur_fn_689( 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_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -56277,18 +58473,19 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56299,18 +58496,19 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56321,18 +58519,19 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56343,14 +58542,15 @@ fn aiur_fn_689( 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_676] = { let __args: [G; IN_676] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -56358,7 +58558,7 @@ fn aiur_fn_689( 0u64 => { let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; break '__mc_0 [__v_30, __v_11]; }, 1u64 => { @@ -56372,7 +58572,7 @@ fn aiur_fn_689( 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_688] = { let __args: [G; IN_688] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -56386,8 +58586,9 @@ fn aiur_fn_689( 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_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56397,15 +58598,15 @@ fn aiur_fn_689( }) } -const INPUT_SIZE_690: usize = 1; -const IN_690: usize = 1; -const OUT_690: usize = 1; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_689: usize = 1; +const IN_689: usize = 1; +const OUT_689: usize = 1; +fn aiur_fn_689( + inp: [G; IN_689], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], ExecError> { +) -> Result<[G; OUT_689], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -56429,45 +58630,49 @@ fn aiur_fn_690( let __v_18: G = __loaded[17]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_690] = [__v_23]; - record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__v_23]; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_691: usize = 1; -const IN_691: usize = 1; -const OUT_691: usize = 1; -fn aiur_fn_691( - inp: [G; IN_691], +const INPUT_SIZE_690: usize = 1; +const IN_690: usize = 1; +const OUT_690: usize = 1; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_691], ExecError> { +) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_691] = [__v_1]; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_690] = [__v_1]; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_691] = [__v_1]; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_690] = [__v_1]; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_691] = [__v_1]; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_690] = [__v_1]; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56477,6 +58682,46 @@ fn aiur_fn_691( }) } +const INPUT_SIZE_691: usize = 3; +const IN_691: usize = 3; +const OUT_691: usize = 0; +fn aiur_fn_691( + inp: [G; IN_691], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_691] = []; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __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_691] = []; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + const INPUT_SIZE_692: usize = 3; const IN_692: usize = 3; const OUT_692: usize = 0; @@ -56494,18 +58739,20 @@ fn aiur_fn_692( 1u64 => { let __ret: [G; OUT_692] = []; record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __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()) }); + 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_692] = []; record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56532,18 +58779,20 @@ fn aiur_fn_693( 1u64 => { let __ret: [G; OUT_693] = []; record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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()) }); + 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_693] = []; record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56570,18 +58819,16 @@ fn aiur_fn_694( 1u64 => { let __ret: [G; OUT_694] = []; record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; - let __v_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()) }); + 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_694] = []; record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56591,8 +58838,8 @@ fn aiur_fn_694( }) } -const INPUT_SIZE_695: usize = 3; -const IN_695: usize = 3; +const INPUT_SIZE_695: usize = 17; +const IN_695: usize = 17; const OUT_695: usize = 0; fn aiur_fn_695( inp: [G; IN_695], @@ -56600,40 +58847,6 @@ fn aiur_fn_695( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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]; - match __v_1.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_695] = []; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!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_695] = []; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_696: usize = 17; -const IN_696: usize = 17; -const OUT_696: usize = 0; -fn aiur_fn_696( - inp: [G; IN_696], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> 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]; @@ -56654,8 +58867,9 @@ fn aiur_fn_696( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_696] = []; - record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -56683,8 +58897,9 @@ fn aiur_fn_696( 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_696] = []; - record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56694,23 +58909,24 @@ fn aiur_fn_696( }) } -const INPUT_SIZE_697: usize = 3; -const IN_697: usize = 3; -const OUT_697: usize = 0; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_696: usize = 3; +const IN_696: usize = 3; +const OUT_696: usize = 0; +fn aiur_fn_696( + inp: [G; IN_696], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_697], 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]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_697] = []; - record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_696] = []; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -56876,8 +59092,9 @@ fn aiur_fn_697( 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_697] = []; - record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_696] = []; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56887,27 +59104,28 @@ fn aiur_fn_697( }) } -const INPUT_SIZE_698: usize = 3; -const IN_698: usize = 3; -const OUT_698: usize = 0; -fn aiur_fn_698( - inp: [G; IN_698], +const INPUT_SIZE_697: usize = 3; +const IN_697: usize = 3; +const OUT_697: usize = 0; +fn aiur_fn_697( + inp: [G; IN_697], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_698], 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]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_698] = []; - record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_697] = []; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -57071,8 +59289,9 @@ fn aiur_fn_698( 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_698] = []; - record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_697] = []; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57082,15 +59301,15 @@ fn aiur_fn_698( }) } -const INPUT_SIZE_699: usize = 10; -const IN_699: usize = 10; -const OUT_699: usize = 0; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_698: usize = 10; +const IN_698: usize = 10; +const OUT_698: usize = 0; +fn aiur_fn_698( + inp: [G; IN_698], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_699], 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]; @@ -57138,8 +59357,9 @@ fn aiur_fn_699( let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_699] = []; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57167,7 +59387,7 @@ fn aiur_fn_699( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; 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()) }); } @@ -57225,9 +59445,10 @@ fn aiur_fn_699( 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_699] = { let __args: [G; IN_699] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_699] = []; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57246,23 +59467,24 @@ fn aiur_fn_699( }) } -const INPUT_SIZE_700: usize = 3; -const IN_700: usize = 3; -const OUT_700: usize = 0; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_699: usize = 3; +const IN_699: usize = 3; +const OUT_699: usize = 0; +fn aiur_fn_699( + inp: [G; IN_699], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_700], 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]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_700] = []; - record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -57274,9 +59496,10 @@ fn aiur_fn_700( 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_699] = { let __args: [G; IN_699] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_700] = []; - record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57286,15 +59509,15 @@ fn aiur_fn_700( }) } -const INPUT_SIZE_701: usize = 49; -const IN_701: usize = 49; -const OUT_701: usize = 0; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_700: usize = 49; +const IN_700: usize = 49; +const OUT_700: usize = 0; +fn aiur_fn_700( + inp: [G; IN_700], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_701], 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]; @@ -57345,7 +59568,7 @@ fn aiur_fn_701( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -57384,14 +59607,15 @@ fn aiur_fn_701( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_701] = []; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_700] = []; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57400,15 +59624,15 @@ fn aiur_fn_701( }) } -const INPUT_SIZE_702: usize = 2; -const IN_702: usize = 2; -const OUT_702: usize = 0; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_701: usize = 2; +const IN_701: usize = 2; +const OUT_701: usize = 0; +fn aiur_fn_701( + inp: [G; IN_701], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_702], 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]; @@ -57465,15 +59689,17 @@ fn aiur_fn_702( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_701] = []; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_701] = []; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57483,29 +59709,31 @@ fn aiur_fn_702( }) } -const INPUT_SIZE_703: usize = 3; -const IN_703: usize = 3; -const OUT_703: usize = 0; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_702: usize = 3; +const IN_702: usize = 3; +const OUT_702: usize = 0; +fn aiur_fn_702( + inp: [G; IN_702], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], 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]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_703] = []; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_703] = []; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57515,15 +59743,15 @@ fn aiur_fn_703( }) } -const INPUT_SIZE_704: usize = 99; -const IN_704: usize = 99; -const OUT_704: usize = 0; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_703: usize = 99; +const IN_703: usize = 99; +const OUT_703: usize = 0; +fn aiur_fn_703( + inp: [G; IN_703], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_704], 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]; @@ -57630,13 +59858,14 @@ fn aiur_fn_704( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57651,14 +59880,15 @@ fn aiur_fn_704( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57673,17 +59903,18 @@ fn aiur_fn_704( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57700,15 +59931,15 @@ fn aiur_fn_704( }) } -const INPUT_SIZE_705: usize = 2; -const IN_705: usize = 2; -const OUT_705: usize = 0; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_704: usize = 2; +const IN_704: usize = 2; +const OUT_704: usize = 0; +fn aiur_fn_704( + inp: [G; IN_704], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_705], ExecError> { +) -> Result<[G; OUT_704], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57779,12 +60010,13 @@ fn aiur_fn_705( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_704] = []; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -57830,10 +60062,11 @@ fn aiur_fn_705( 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_704] = { let __args: [G; IN_704] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_704] = []; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57843,15 +60076,15 @@ fn aiur_fn_705( }) } -const INPUT_SIZE_706: usize = 55; -const IN_706: usize = 55; -const OUT_706: usize = 0; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_705: usize = 55; +const IN_705: usize = 55; +const OUT_705: usize = 0; +fn aiur_fn_705( + inp: [G; IN_705], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], ExecError> { +) -> Result<[G; OUT_705], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57965,13 +60198,14 @@ fn aiur_fn_706( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57986,17 +60220,18 @@ fn aiur_fn_706( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58011,11 +60246,12 @@ fn aiur_fn_706( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58030,11 +60266,12 @@ fn aiur_fn_706( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58049,11 +60286,12 @@ fn aiur_fn_706( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58068,10 +60306,11 @@ fn aiur_fn_706( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58086,10 +60325,11 @@ fn aiur_fn_706( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58104,10 +60344,11 @@ fn aiur_fn_706( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58120,9 +60361,10 @@ fn aiur_fn_706( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58139,41 +60381,42 @@ fn aiur_fn_706( }) } -const INPUT_SIZE_707: usize = 2; -const IN_707: usize = 2; -const OUT_707: usize = 0; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_706: usize = 2; +const IN_706: usize = 2; +const OUT_706: usize = 0; +fn aiur_fn_706( + inp: [G; IN_706], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], ExecError> { +) -> Result<[G; OUT_706], 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_667] = { let __args: [G; IN_667] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __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_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_708: usize = 32; -const IN_708: usize = 32; -const OUT_708: usize = 0; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_707: usize = 32; +const IN_707: usize = 32; +const OUT_707: usize = 0; +fn aiur_fn_707( + inp: [G; IN_707], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_707], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58245,23 +60488,24 @@ fn aiur_fn_708( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; match __v_57.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(1); let __v_62: G = G::from_u64(1); - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_60, __v_61, __v_62, __v_62, __v_62, __v_62, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_60, __v_61, __v_62, __v_62, __v_62, __v_62, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; @@ -58271,9 +60515,10 @@ fn aiur_fn_708( let __v_69: G = G::from_u64(1); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_55, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_55, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58285,20 +60530,21 @@ fn aiur_fn_708( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_55, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_55, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -58354,9 +60600,10 @@ fn aiur_fn_708( let __v_109: G = __r_arr[52]; let __v_110: G = __r_arr[53]; let __v_111: G = __r_arr[54]; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_55, __v_57, __v_58, __v_59, __v_60, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_55, __v_57, __v_58, __v_59, __v_60, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -58366,9 +60613,10 @@ fn aiur_fn_708( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_55, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_55, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58378,15 +60626,15 @@ fn aiur_fn_708( }) } -const INPUT_SIZE_709: usize = 32; -const IN_709: usize = 32; -const OUT_709: usize = 0; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_708: usize = 32; +const IN_708: usize = 32; +const OUT_708: usize = 0; +fn aiur_fn_708( + inp: [G; IN_708], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], ExecError> { +) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58420,27 +60668,28 @@ fn aiur_fn_709( let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_709] = []; - record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_710: usize = 3; -const IN_710: usize = 3; -const OUT_710: usize = 1; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_709: usize = 3; +const IN_709: usize = 3; +const OUT_709: usize = 1; +fn aiur_fn_709( + inp: [G; IN_709], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], ExecError> { +) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(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_729] = { let __args: [G; IN_729] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -58448,13 +60697,15 @@ fn aiur_fn_710( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_710] = [__v_2]; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_709] = [__v_2]; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_710] = [__v_5]; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_709] = [__v_5]; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58464,15 +60715,15 @@ fn aiur_fn_710( }) } -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_710: usize = 2; +const IN_710: usize = 2; +const OUT_710: usize = 1; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_711], 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]; @@ -58485,19 +60736,21 @@ fn aiur_fn_711( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_711] = [__v_9]; - record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_710] = [__v_9]; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_711] = [__v_7]; - record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_710] = [__v_7]; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58507,15 +60760,15 @@ fn aiur_fn_711( }) } -const INPUT_SIZE_712: usize = 1; -const IN_712: usize = 1; -const OUT_712: usize = 8; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_711: usize = 1; +const IN_711: usize = 1; +const OUT_711: usize = 8; +fn aiur_fn_711( + inp: [G; IN_711], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], ExecError> { +) -> Result<[G; OUT_711], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -58539,12 +60792,13 @@ fn aiur_fn_712( 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_712] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_711] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -58562,8 +60816,9 @@ fn aiur_fn_712( 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_712] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_711] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58573,15 +60828,15 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 2; -const IN_713: usize = 2; -const OUT_713: usize = 1; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_712: usize = 2; +const IN_712: usize = 2; +const OUT_712: usize = 1; +fn aiur_fn_712( + inp: [G; IN_712], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_713], ExecError> { +) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58592,17 +60847,19 @@ fn aiur_fn_713( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_713] = [__v_1]; - record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_712] = [__v_1]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_713] = [__v_8]; - record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_712] = [__v_8]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58612,15 +60869,15 @@ fn aiur_fn_713( }) } -const INPUT_SIZE_714: usize = 1; -const IN_714: usize = 1; -const OUT_714: usize = 8; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_713: usize = 1; +const IN_713: usize = 1; +const OUT_713: usize = 8; +fn aiur_fn_713( + inp: [G; IN_713], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], ExecError> { +) -> Result<[G; OUT_713], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -58637,12 +60894,13 @@ fn aiur_fn_714( 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_714] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_713] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -58660,8 +60918,9 @@ fn aiur_fn_714( 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_714] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_713] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58671,15 +60930,15 @@ fn aiur_fn_714( }) } -const INPUT_SIZE_715: usize = 8; -const IN_715: usize = 8; -const OUT_715: usize = 1; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_714: usize = 8; +const IN_714: usize = 8; +const OUT_714: usize = 1; +fn aiur_fn_714( + inp: [G; IN_714], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], 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]; @@ -58691,8 +60950,9 @@ fn aiur_fn_715( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_715] = [__v_7]; - record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = [__v_7]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -58713,25 +60973,28 @@ fn aiur_fn_715( 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_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_715] = [__v_21]; - record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = [__v_21]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_21: G = (__v_0 - __v_3); match __v_21.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_715] = [__v_4]; - record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = [__v_4]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_715] = [__v_22]; - record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = [__v_22]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58745,37 +61008,38 @@ fn aiur_fn_715( }) } -const INPUT_SIZE_716: usize = 1; -const IN_716: usize = 1; -const OUT_716: usize = 1; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_715: usize = 1; +const IN_715: usize = 1; +const OUT_715: usize = 1; +fn aiur_fn_715( + inp: [G; IN_715], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], ExecError> { +) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_716] = [__v_4]; - record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_715] = [__v_4]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } -const INPUT_SIZE_717: usize = 2; -const IN_717: usize = 2; -const OUT_717: usize = 1; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_716: usize = 2; +const IN_716: usize = 2; +const OUT_716: usize = 1; +fn aiur_fn_716( + inp: [G; IN_716], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], ExecError> { +) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58785,17 +61049,19 @@ fn aiur_fn_717( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_717] = [__v_1]; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_716] = [__v_1]; + record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_717] = [__v_7]; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_716] = [__v_7]; + record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58805,15 +61071,15 @@ fn aiur_fn_717( }) } -const INPUT_SIZE_718: usize = 1; -const IN_718: usize = 1; -const OUT_718: usize = 1; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_717: usize = 1; +const IN_717: usize = 1; +const OUT_717: usize = 1; +fn aiur_fn_717( + inp: [G; IN_717], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_718], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -58823,17 +61089,19 @@ fn aiur_fn_718( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_718] = [__v_4]; - record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_717] = [__v_4]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __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_718] = [__v_6]; - record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_717] = [__v_6]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58843,15 +61111,15 @@ fn aiur_fn_718( }) } -const INPUT_SIZE_719: usize = 1; -const IN_719: usize = 1; -const OUT_719: usize = 8; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_718: usize = 1; +const IN_718: usize = 1; +const OUT_718: usize = 8; +fn aiur_fn_718( + inp: [G; IN_718], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_719], ExecError> { +) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -58901,12 +61169,13 @@ fn aiur_fn_719( 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_719] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_718] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -58924,8 +61193,9 @@ fn aiur_fn_719( 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_719] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_718] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58935,19 +61205,19 @@ fn aiur_fn_719( }) } -const INPUT_SIZE_720: usize = 2; -const IN_720: usize = 2; -const OUT_720: usize = 1; -fn aiur_fn_720( - inp: [G; IN_720], +const INPUT_SIZE_719: usize = 2; +const IN_719: usize = 2; +const OUT_719: usize = 1; +fn aiur_fn_719( + inp: [G; IN_719], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_720], ExecError> { +) -> Result<[G; OUT_719], 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_729] = { let __args: [G; IN_729] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -58955,8 +61225,9 @@ fn aiur_fn_720( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_720] = [__v_4]; - record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_719] = [__v_4]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58966,15 +61237,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 1; -const IN_721: usize = 1; -const OUT_721: usize = 1; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_720: usize = 1; +const IN_720: usize = 1; +const OUT_720: usize = 1; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], ExecError> { +) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -58991,17 +61262,19 @@ fn aiur_fn_721( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_721] = [__v_11]; - record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_720] = [__v_11]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __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_721] = [__v_13]; - record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_720] = [__v_13]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59011,15 +61284,15 @@ fn aiur_fn_721( }) } -const INPUT_SIZE_722: usize = 9; -const IN_722: usize = 9; -const OUT_722: usize = 45; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_721: usize = 9; +const IN_721: usize = 9; +const OUT_721: usize = 45; +fn aiur_fn_721( + inp: [G; IN_721], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], 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]; @@ -59084,8 +61357,9 @@ fn aiur_fn_722( let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_722] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_721] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -59098,7 +61372,7 @@ fn aiur_fn_722( 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_722] = { let __args: [G; IN_722] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -59144,8 +61418,9 @@ fn aiur_fn_722( 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_722] = [__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[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59160,15 +61435,15 @@ fn aiur_fn_722( }) } -const INPUT_SIZE_723: usize = 1; -const IN_723: usize = 1; -const OUT_723: usize = 8; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_722: usize = 1; +const IN_722: usize = 1; +const OUT_722: usize = 8; +fn aiur_fn_722( + inp: [G; IN_722], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_723], ExecError> { +) -> Result<[G; OUT_722], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -59229,12 +61504,13 @@ fn aiur_fn_723( 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_723] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -59252,8 +61528,9 @@ fn aiur_fn_723( 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_723] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59263,15 +61540,15 @@ fn aiur_fn_723( }) } -const INPUT_SIZE_724: usize = 1; -const IN_724: usize = 1; -const OUT_724: usize = 8; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_723: usize = 1; +const IN_723: usize = 1; +const OUT_723: usize = 8; +fn aiur_fn_723( + inp: [G; IN_723], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], ExecError> { +) -> Result<[G; OUT_723], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -59296,12 +61573,13 @@ fn aiur_fn_724( 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_724] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_723] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -59319,8 +61597,9 @@ fn aiur_fn_724( 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_724] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_723] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59330,15 +61609,15 @@ fn aiur_fn_724( }) } -const INPUT_SIZE_725: usize = 9; -const IN_725: usize = 9; -const OUT_725: usize = 34; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_724: usize = 9; +const IN_724: usize = 9; +const OUT_724: usize = 34; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], 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]; @@ -59392,8 +61671,9 @@ fn aiur_fn_725( let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_725] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_724] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -59406,7 +61686,7 @@ fn aiur_fn_725( 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_725] = { let __args: [G; IN_725] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -59441,8 +61721,9 @@ fn aiur_fn_725( 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_725] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __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[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_724] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59457,15 +61738,15 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 1; -const IN_726: usize = 1; -const OUT_726: usize = 1; -fn aiur_fn_726( - inp: [G; IN_726], +const INPUT_SIZE_725: usize = 1; +const IN_725: usize = 1; +const OUT_725: usize = 1; +fn aiur_fn_725( + inp: [G; IN_725], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_726], ExecError> { +) -> Result<[G; OUT_725], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -59475,14 +61756,16 @@ fn aiur_fn_726( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_726] = [__v_4]; - record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_4]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_726] = [__v_4]; - record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_4]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59492,15 +61775,15 @@ fn aiur_fn_726( }) } -const INPUT_SIZE_727: usize = 5; -const IN_727: usize = 5; -const OUT_727: usize = 1; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_726: usize = 5; +const IN_726: usize = 5; +const OUT_726: usize = 1; +fn aiur_fn_726( + inp: [G; IN_726], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], ExecError> { +) -> Result<[G; OUT_726], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59519,19 +61802,21 @@ fn aiur_fn_727( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_727] = [__v_15]; - record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_726] = [__v_15]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_727] = [__v_13]; - record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_726] = [__v_13]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59541,15 +61826,15 @@ fn aiur_fn_727( }) } -const INPUT_SIZE_728: usize = 2; -const IN_728: usize = 2; -const OUT_728: usize = 1; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 1; +fn aiur_fn_727( + inp: [G; IN_727], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], 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]; @@ -59557,9 +61842,10 @@ fn aiur_fn_728( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_728] = [__v_4]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_727] = [__v_4]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59572,11 +61858,12 @@ fn aiur_fn_728( 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_728] = { let __args: [G; IN_728] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_728] = [__v_9]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_727] = [__v_9]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59588,28 +61875,29 @@ fn aiur_fn_728( }) } -const INPUT_SIZE_729: usize = 2; -const IN_729: usize = 2; -const OUT_729: usize = 1; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_728: usize = 2; +const IN_728: usize = 2; +const OUT_728: usize = 1; +fn aiur_fn_728( + inp: [G; IN_728], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_729] = [__v_0]; - record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_728] = [__v_0]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -59617,8 +61905,9 @@ fn aiur_fn_729( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_729] = [__v_7]; - record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_728] = [__v_7]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59630,15 +61919,15 @@ fn aiur_fn_729( }) } -const INPUT_SIZE_730: usize = 1; -const IN_730: usize = 1; -const OUT_730: usize = 1; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_729: usize = 1; +const IN_729: usize = 1; +const OUT_729: usize = 1; +fn aiur_fn_729( + inp: [G; IN_729], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], ExecError> { +) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; @@ -59650,17 +61939,19 @@ fn aiur_fn_730( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_730] = [__v_6]; - record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_6]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __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_730] = [__v_8]; - record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_8]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59670,15 +61961,15 @@ fn aiur_fn_730( }) } -const INPUT_SIZE_731: usize = 8; -const IN_731: usize = 8; -const OUT_731: usize = 6; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_730: usize = 8; +const IN_730: usize = 8; +const OUT_730: usize = 6; +fn aiur_fn_730( + inp: [G; IN_730], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], 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]; @@ -59688,7 +61979,7 @@ fn aiur_fn_731( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -59699,8 +61990,9 @@ fn aiur_fn_731( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_731] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_730] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59710,15 +62002,15 @@ fn aiur_fn_731( }) } -const INPUT_SIZE_732: usize = 9; -const IN_732: usize = 9; -const OUT_732: usize = 1; -fn aiur_fn_732( - inp: [G; IN_732], +const INPUT_SIZE_731: usize = 9; +const IN_731: usize = 9; +const OUT_731: usize = 1; +fn aiur_fn_731( + inp: [G; IN_731], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], 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]; @@ -59745,19 +62037,21 @@ fn aiur_fn_732( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_732] = [__v_23]; - record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_731] = [__v_23]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_732] = [__v_21]; - record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_731] = [__v_21]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59767,15 +62061,15 @@ fn aiur_fn_732( }) } -const INPUT_SIZE_733: usize = 1; -const IN_733: usize = 1; -const OUT_733: usize = 1; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_732: usize = 1; +const IN_732: usize = 1; +const OUT_732: usize = 1; +fn aiur_fn_732( + inp: [G; IN_732], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_732], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -59788,17 +62082,19 @@ fn aiur_fn_733( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_733] = [__v_7]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_7]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __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_733] = [__v_9]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_9]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59808,15 +62104,15 @@ fn aiur_fn_733( }) } -const INPUT_SIZE_734: usize = 2; -const IN_734: usize = 2; -const OUT_734: usize = 1; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_733: usize = 2; +const IN_733: usize = 2; +const OUT_733: usize = 1; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], 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]; @@ -59826,17 +62122,19 @@ fn aiur_fn_734( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_734] = [__v_1]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__v_1]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_734] = [__v_7]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__v_7]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59846,15 +62144,15 @@ fn aiur_fn_734( }) } -const INPUT_SIZE_735: usize = 8; -const IN_735: usize = 8; -const OUT_735: usize = 6; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_734: usize = 8; +const IN_734: usize = 8; +const OUT_734: usize = 6; +fn aiur_fn_734( + inp: [G; IN_734], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_734], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59870,12 +62168,13 @@ fn aiur_fn_735( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_735] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_734] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -59896,22 +62195,23 @@ fn aiur_fn_735( 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_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __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_736] = { let __args: [G; IN_736] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __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_735] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_734] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59919,29 +62219,31 @@ fn aiur_fn_735( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_735] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_734] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __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_736] = { let __args: [G; IN_736] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __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_735] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_734] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -59955,15 +62257,15 @@ fn aiur_fn_735( }) } -const INPUT_SIZE_736: usize = 15; -const IN_736: usize = 15; -const OUT_736: usize = 6; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_735: usize = 15; +const IN_735: usize = 15; +const OUT_735: usize = 6; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_735], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59982,38 +62284,40 @@ fn aiur_fn_736( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __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_736] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_735] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_737: usize = 14; -const IN_737: usize = 14; -const OUT_737: usize = 6; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_736: usize = 14; +const IN_736: usize = 14; +const OUT_736: usize = 6; +fn aiur_fn_736( + inp: [G; IN_736], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], 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]; @@ -60048,13 +62352,14 @@ fn aiur_fn_737( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60073,13 +62378,14 @@ fn aiur_fn_737( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60102,13 +62408,14 @@ fn aiur_fn_737( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60127,22 +62434,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60150,10 +62459,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60176,22 +62486,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60199,10 +62511,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60212,10 +62525,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60223,10 +62537,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60253,13 +62568,14 @@ fn aiur_fn_737( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60278,22 +62594,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60301,10 +62619,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60327,22 +62646,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60350,10 +62671,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60363,10 +62685,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60374,10 +62697,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60402,13 +62726,14 @@ fn aiur_fn_737( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60431,13 +62756,14 @@ fn aiur_fn_737( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60456,22 +62782,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60479,10 +62807,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60505,22 +62834,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60528,10 +62859,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60541,10 +62873,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60552,10 +62885,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60582,13 +62916,14 @@ fn aiur_fn_737( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60607,22 +62942,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60630,10 +62967,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60656,22 +62994,24 @@ fn aiur_fn_737( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60679,10 +63019,11 @@ fn aiur_fn_737( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60692,10 +63033,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60703,10 +63045,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60735,13 +63078,14 @@ fn aiur_fn_737( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60760,22 +63104,24 @@ fn aiur_fn_737( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60783,10 +63129,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60809,22 +63156,24 @@ fn aiur_fn_737( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60832,10 +63181,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60845,10 +63195,11 @@ fn aiur_fn_737( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60856,10 +63207,11 @@ fn aiur_fn_737( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60886,13 +63238,14 @@ fn aiur_fn_737( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60911,22 +63264,24 @@ fn aiur_fn_737( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60934,10 +63289,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60960,22 +63316,24 @@ fn aiur_fn_737( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60983,10 +63341,11 @@ fn aiur_fn_737( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60996,10 +63355,11 @@ fn aiur_fn_737( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -61007,10 +63367,11 @@ fn aiur_fn_737( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -64711,11 +67072,6 @@ pub(crate) fn execute_generated( let __out = aiur_fn_736(__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)?; - return Ok(__out.to_vec()); - }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, diff --git a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs index 325ad48c4..b749bc7bb 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs @@ -34,10 +34,26 @@ pub fn execute_ixvm( args: Vec, io_buffer: &mut IOBuffer, ) -> Result<(QueryRecord, Vec), ExecError> { + let mut record = QueryRecord::new(toplevel); + let output = + execute_ixvm_with_record(toplevel, fun_idx, &args, io_buffer, &mut record)?; + if aiur::execute::query_stats_enabled() { + aiur::execute::dump_query_stats(&record, "ixvm final"); + } + Ok((record, output)) +} + +/// Like [`execute_ixvm`] but accumulating into a caller-owned record — +/// see `aiur::execute::Toplevel::execute_with_record`. +pub fn execute_ixvm_with_record( + toplevel: &Toplevel, + fun_idx: FunIdx, + args: &[G], + io_buffer: &mut IOBuffer, + record: &mut QueryRecord, +) -> Result, ExecError> { if !toplevel.functions[fun_idx].entry { return Err(ExecError::NotEntryFunction(fun_idx)); } - let mut record = QueryRecord::new(toplevel); - let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; - Ok((record, output)) + execute_generated(fun_idx, args, record, io_buffer) } diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index cc4c049b1..787376073 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -14,7 +14,7 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; -use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_add_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; +use aiur::execute::{ ExecError, IOBuffer, QueryRecord, record_budget_exceeded, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_add_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 3; const IN_0: usize = 3; @@ -33,9 +33,10 @@ fn aiur_fn_0( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_0] = [__v_5]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48,9 +49,10 @@ fn aiur_fn_0( let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_0] = [__v_10]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -94,12 +96,14 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -108,6 +112,7 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -116,6 +121,7 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -124,6 +130,7 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -132,6 +139,7 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -140,6 +148,7 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -148,6 +157,7 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -156,6 +166,7 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -205,6 +216,7 @@ fn aiur_fn_2( let __v_23: G = __b2_add.1; let __ret: [G; OUT_2] = [__v_8, __v_12, __v_17, __v_22]; record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -233,6 +245,7 @@ fn aiur_fn_3( let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_3] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -253,6 +266,7 @@ fn aiur_fn_4( let __v_3: G = inp[3]; let __ret: [G; OUT_4] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -273,6 +287,7 @@ fn aiur_fn_5( let __v_3: G = inp[3]; let __ret: [G; OUT_5] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -303,6 +318,7 @@ fn aiur_fn_6( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_6] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -333,6 +349,7 @@ fn aiur_fn_7( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_7] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -381,6 +398,7 @@ fn aiur_fn_8( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -395,6 +413,7 @@ fn aiur_fn_8( let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -410,6 +429,7 @@ fn aiur_fn_8( let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -424,6 +444,7 @@ fn aiur_fn_8( let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -437,6 +458,7 @@ fn aiur_fn_8( let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -449,6 +471,7 @@ fn aiur_fn_8( let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -460,6 +483,7 @@ fn aiur_fn_8( let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -470,6 +494,7 @@ fn aiur_fn_8( let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_8] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -479,6 +504,7 @@ fn aiur_fn_8( let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_8] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -527,6 +553,7 @@ fn aiur_fn_9( let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_9] = [__v_26]; record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -572,6 +599,7 @@ fn aiur_fn_10( let __v_28: G = (__v_0 + __v_27); let __ret: [G; OUT_10] = [__v_28]; record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -611,6 +639,7 @@ fn aiur_fn_11( let __v_22: G = (__v_18 - __v_21); let __ret: [G; OUT_11] = [__v_22]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -652,6 +681,7 @@ fn aiur_fn_12( } let __ret: [G; OUT_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -671,6 +701,7 @@ fn aiur_fn_13( let __v_2: G = (__v_0 + __v_1); let __ret: [G; OUT_13] = [__v_2]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -690,6 +721,7 @@ fn aiur_fn_14( let __v_2: G = (__v_0 * __v_1); let __ret: [G; OUT_14] = [__v_2]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -708,6 +740,7 @@ fn aiur_fn_15( let __v_1: G = (__v_0 * __v_0); let __ret: [G; OUT_15] = [__v_1]; record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -739,6 +772,7 @@ fn aiur_fn_16( } let __ret: [G; OUT_16] = [__v_1]; record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -761,6 +795,7 @@ fn aiur_fn_17( let __v_5: G = (__v_1 + __v_3); let __ret: [G; OUT_17] = [__v_4, __v_5]; record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -783,6 +818,7 @@ fn aiur_fn_18( let __v_5: G = (__v_1 - __v_3); let __ret: [G; OUT_18] = [__v_4, __v_5]; record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -805,6 +841,7 @@ fn aiur_fn_19( let __v_5: G = (__v_4 - __v_1); let __ret: [G; OUT_19] = [__v_3, __v_5]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -833,6 +870,7 @@ fn aiur_fn_20( let __v_11: G = (__v_9 + __v_10); let __ret: [G; OUT_20] = [__v_8, __v_11]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -874,6 +912,7 @@ fn aiur_fn_21( let __v_18: G = (__v_17 * __v_7); let __ret: [G; OUT_21] = [__v_15, __v_18]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -900,6 +939,7 @@ fn aiur_fn_22( let __v_7: G = __r_arr[1]; let __ret: [G; OUT_22] = [__v_6, __v_7]; record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -925,6 +965,7 @@ fn aiur_fn_23( let __v_8: G = (__v_5 * __v_7); let __ret: [G; OUT_23] = [__v_8]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -948,15 +989,17 @@ fn aiur_fn_24( 0u64 => { let __ret: [G; OUT_24] = [__v_2, __v_3]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_24] = [__v_4, __v_7]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1003,6 +1046,7 @@ fn aiur_fn_25( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_25] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1032,6 +1076,7 @@ fn aiur_fn_26( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_10, __v_9]; record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1054,6 +1099,7 @@ fn aiur_fn_27( let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_27] = [__v_2, __v_4]; record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1083,6 +1129,7 @@ fn aiur_fn_28( let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_28] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1112,6 +1159,7 @@ fn aiur_fn_29( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_10, __v_9]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1153,6 +1201,7 @@ fn aiur_fn_30( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_30] = [__v_19, __v_20, __v_18]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1210,6 +1259,7 @@ fn aiur_fn_31( let __v_36: G = __r_arr[8]; let __ret: [G; OUT_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1233,6 +1283,7 @@ fn aiur_fn_32( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_32] = [__v_3, __v_4]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1253,9 +1304,10 @@ fn aiur_fn_33( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_33] = [__v_4, __v_0]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1268,9 +1320,10 @@ fn aiur_fn_33( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_33] = [__v_9, __v_7]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1296,6 +1349,7 @@ fn aiur_fn_34( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1316,9 +1370,10 @@ fn aiur_fn_35( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_35] = [__v_4, __v_0]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1338,9 +1393,10 @@ fn aiur_fn_35( let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_35] = [__v_16, __v_14]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1366,6 +1422,7 @@ fn aiur_fn_36( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1386,9 +1443,10 @@ fn aiur_fn_37( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_37] = [__v_4, __v_0]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1402,9 +1460,10 @@ fn aiur_fn_37( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_37] = [__v_10, __v_8]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1430,6 +1489,7 @@ fn aiur_fn_38( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1450,9 +1510,10 @@ fn aiur_fn_39( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_39] = [__v_4, __v_0]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1496,9 +1557,10 @@ fn aiur_fn_39( let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_39] = [__v_40, __v_38]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1524,6 +1586,7 @@ fn aiur_fn_40( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1544,9 +1607,10 @@ fn aiur_fn_41( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_41] = [__v_4, __v_0]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1559,9 +1623,10 @@ fn aiur_fn_41( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_41] = [__v_9, __v_7]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1587,6 +1652,7 @@ fn aiur_fn_42( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1607,9 +1673,10 @@ fn aiur_fn_43( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_43] = [__v_4, __v_0]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1622,9 +1689,10 @@ fn aiur_fn_43( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_43] = [__v_9, __v_7]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1650,6 +1718,7 @@ fn aiur_fn_44( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1670,9 +1739,10 @@ fn aiur_fn_45( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_45] = [__v_4, __v_0]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1685,9 +1755,10 @@ fn aiur_fn_45( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_45] = [__v_9, __v_7]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1710,6 +1781,7 @@ fn aiur_fn_46( let __v_2: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_1, __v_2]; record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1733,6 +1805,7 @@ fn aiur_fn_47( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_47] = [__v_3, __v_4]; record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1753,9 +1826,10 @@ fn aiur_fn_48( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_48] = [__v_4, __v_0]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1768,9 +1842,10 @@ fn aiur_fn_48( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_48] = [__v_9, __v_7]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1799,6 +1874,7 @@ fn aiur_fn_49( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1822,6 +1898,7 @@ fn aiur_fn_50( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_50] = [__v_1, __v_3, __v_4]; record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1845,6 +1922,7 @@ fn aiur_fn_51( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_3, __v_4]; record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1865,9 +1943,10 @@ fn aiur_fn_52( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_52] = [__v_4, __v_0]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1881,9 +1960,10 @@ fn aiur_fn_52( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_52] = [__v_10, __v_8]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1912,6 +1992,7 @@ fn aiur_fn_53( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1935,6 +2016,7 @@ fn aiur_fn_54( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_54] = [__v_3, __v_4]; record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1955,9 +2037,10 @@ fn aiur_fn_55( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_55] = [__v_4, __v_0]; record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1972,9 +2055,10 @@ fn aiur_fn_55( 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; 5] = [__v_10, __v_2, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 5] = [__v_10, __v_2, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_55] = [__v_11, __v_9]; record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2000,6 +2084,7 @@ fn aiur_fn_56( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_1, __v_3, __v_4]; record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2023,6 +2108,7 @@ fn aiur_fn_57( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_57] = [__v_3, __v_4]; record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2043,9 +2129,10 @@ fn aiur_fn_58( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_58] = [__v_4, __v_0]; record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2059,9 +2146,10 @@ fn aiur_fn_58( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_58] = [__v_10, __v_8]; record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2103,6 +2191,7 @@ fn aiur_fn_59( let __v_17: G = __r_arr[8]; let __ret: [G; OUT_59] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2127,6 +2216,7 @@ fn aiur_fn_60( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_60] = [__v_3, __v_4, __v_2]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2136,6 +2226,7 @@ fn aiur_fn_60( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_60] = [__v_5, __v_3, __v_4]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2196,6 +2287,7 @@ fn aiur_fn_61( let __v_32: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_1, __v_3, __v_4, __v_5, __v_7, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_24, __v_26, __v_27, __v_29, __v_31, __v_32]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2245,7 +2337,7 @@ fn aiur_fn_62( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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); @@ -2256,11 +2348,11 @@ fn aiur_fn_62( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -2333,6 +2425,7 @@ fn aiur_fn_62( let __v_117: G = __r_arr[31]; let __ret: [G; OUT_62] = [__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]; record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2421,6 +2514,7 @@ fn aiur_fn_63( let __v_69: G = G::from_u64(1); let __ret: [G; OUT_63] = [__v_67, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -2533,6 +2627,7 @@ fn aiur_fn_63( let __v_169: G = G::from_u64(1); let __ret: [G; OUT_63] = [__v_169, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -2619,9 +2714,10 @@ fn aiur_fn_63( let __v_246: G = G::from_u64(0); let __v_247: G = G::from_u64(0); let __v_248: G = G::from_u64(0); - let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_63] = [__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_248, __v_249, __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, __v_242, __v_243, __v_244, __v_245]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2670,9 +2766,10 @@ fn aiur_fn_63( let __v_244: G = G::from_u64(0); let __v_245: G = G::from_u64(0); let __v_246: G = G::from_u64(0); - let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_63] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __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, __v_242, __v_243]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2774,6 +2871,7 @@ fn aiur_fn_64( 1u64 => { let __ret: [G; OUT_64] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2918,11 +3016,12 @@ fn aiur_fn_64( let __v_201: G = __r_arr[31]; let __ret: [G; OUT_64] = [__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, __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]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_170: G = G::from_u64(0); - let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_170, __v_171, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; @@ -2958,6 +3057,7 @@ fn aiur_fn_64( let __v_203: G = __r_arr[31]; let __ret: [G; OUT_64] = [__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, __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]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3001,17 +3101,19 @@ fn aiur_fn_65( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_10]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_12]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3023,6 +3125,7 @@ fn aiur_fn_65( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_16]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -3431,6 +3534,7 @@ fn aiur_fn_66( 0u64 => { let __ret: [G; OUT_66] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3771,18 +3875,20 @@ fn aiur_fn_67( 0u64 => { let __ret: [G; OUT_67] = [__v_0]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_7]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -3980,14 +4086,16 @@ fn aiur_fn_68( let __v_154: G = __r_arr[29]; let __v_155: G = __r_arr[30]; let __v_156: G = __r_arr[31]; - let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_68] = [__v_157]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -3995,6 +4103,7 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4002,6 +4111,7 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4009,6 +4119,7 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4016,6 +4127,7 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4023,6 +4135,7 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4030,6 +4143,7 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4037,6 +4151,7 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4076,9 +4191,10 @@ fn aiur_fn_68( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_68] = [__v_42]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4246,9 +4362,10 @@ fn aiur_fn_68( let __v_161: G = __r_arr[29]; let __v_162: G = __r_arr[30]; let __v_163: G = __r_arr[31]; - let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_68] = [__v_164]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4466,10 +4583,10 @@ fn aiur_fn_69( let __v_189: G = __r_arr[29]; let __v_190: G = __r_arr[30]; let __v_191: G = __r_arr[31]; - let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_193: G = G::from_u64(1); let __v_194: G = G::from_u64(1); - let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_196: G = G::from_u64(0); let __v_197: G = G::from_u64(0); let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; @@ -4490,12 +4607,13 @@ fn aiur_fn_69( let __v_211: G = __r_arr[5]; let __v_212: G = __r_arr[6]; let __v_213: G = __r_arr[7]; - let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_216: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_216]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -4601,15 +4719,16 @@ fn aiur_fn_69( let __v_165: G = __r_arr[31]; let __v_166: G = G::from_u64(1); let __v_167: G = G::from_u64(1); - let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_169: G = G::from_u64(0); let __v_170: G = G::from_u64(1); let __v_171: G = (__v_2 + __v_170); - let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_173: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_173]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4826,6 +4945,7 @@ fn aiur_fn_70( let __v_151: G = (__v_148 + __v_146); let __ret: [G; OUT_70] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -5106,6 +5226,7 @@ fn aiur_fn_71( let __v_255: G = __r_arr[15]; let __ret: [G; OUT_71] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __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[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6185,6 +6306,7 @@ fn aiur_fn_72( let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) }; let __ret: [G; OUT_72] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055]; record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6207,6 +6329,7 @@ fn aiur_fn_73( let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_73] = [__v_2, __v_4]; record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6233,6 +6356,7 @@ fn aiur_fn_74( let __v_8: G = (__v_0 + __v_7); let __ret: [G; OUT_74] = [__v_6, __v_8]; record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6265,6 +6389,7 @@ fn aiur_fn_75( let __v_14: G = (__v_0 + __v_13); let __ret: [G; OUT_75] = [__v_6, __v_2, __v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6303,6 +6428,7 @@ fn aiur_fn_76( let __v_20: G = (__v_0 + __v_19); let __ret: [G; OUT_76] = [__v_14, __v_2, __v_3, __v_4, __v_5, __v_15, __v_16, __v_17, __v_18, __v_20]; record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6332,6 +6458,7 @@ fn aiur_fn_77( let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_77] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6361,6 +6488,7 @@ fn aiur_fn_78( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_10, __v_9]; record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6418,6 +6546,7 @@ fn aiur_fn_79( let __v_36: G = __r_arr[8]; let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6438,9 +6567,10 @@ fn aiur_fn_80( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_80] = [__v_4, __v_0]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6484,9 +6614,10 @@ fn aiur_fn_80( let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_80] = [__v_40, __v_38]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6516,6 +6647,7 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -6526,6 +6658,7 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -6536,6 +6669,7 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -6543,6 +6677,7 @@ fn aiur_fn_81( let __v_4: G = G::from_u64(3); let __ret: [G; OUT_81] = [__v_3, __v_4, __v_4, __v_4, __v_2]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -6550,6 +6685,7 @@ fn aiur_fn_81( let __v_4: G = G::from_u64(4); let __ret: [G; OUT_81] = [__v_3, __v_4, __v_4, __v_4, __v_2]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -6557,6 +6693,7 @@ fn aiur_fn_81( let __v_4: G = G::from_u64(5); let __ret: [G; OUT_81] = [__v_3, __v_4, __v_4, __v_4, __v_2]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -6570,6 +6707,7 @@ fn aiur_fn_81( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_7, __v_3, __v_5, __v_8, __v_6]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -6583,6 +6721,7 @@ fn aiur_fn_81( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_7, __v_3, __v_5, __v_8, __v_6]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -6596,6 +6735,7 @@ fn aiur_fn_81( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_7, __v_3, __v_5, __v_8, __v_6]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -6606,6 +6746,7 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -6617,6 +6758,7 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { @@ -6628,6 +6770,7 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 12u64 => { @@ -6639,6 +6782,7 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { @@ -6650,6 +6794,7 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 14u64 => { @@ -6661,6 +6806,7 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6672,6 +6818,7 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6694,9 +6841,10 @@ fn aiur_fn_82( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_82] = [__v_4, __v_0]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6712,9 +6860,10 @@ fn aiur_fn_82( let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_9]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_9]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_82] = [__v_12, __v_10]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6737,9 +6886,10 @@ fn aiur_fn_83( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_83] = [__v_4, __v_0]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6752,9 +6902,10 @@ fn aiur_fn_83( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_83] = [__v_9, __v_7]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6783,6 +6934,7 @@ fn aiur_fn_84( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_84] = [__v_1, __v_5, __v_6]; record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6803,9 +6955,10 @@ fn aiur_fn_85( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_85] = [__v_4, __v_0]; record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6819,9 +6972,10 @@ fn aiur_fn_85( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_85] = [__v_10, __v_8]; record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6935,6 +7089,7 @@ fn aiur_fn_86( let __v_72: G = __r_arr[7]; let __ret: [G; OUT_86] = [__v_43, __v_41, __v_47, __v_31, __v_51, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __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_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_52]; record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7004,14 +7159,15 @@ fn aiur_fn_87( 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 = { let __values: [G; 10] = [__v_54, __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(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_56: G = { let __values: [G; 10] = [__v_53, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_55]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_57: G = { let __values: [G; 10] = [__v_52, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_58: G = { let __values: [G; 10] = [__v_51, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_57]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_59: G = { let __values: [G; 10] = [__v_50, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_58]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_60: G = { let __values: [G; 10] = [__v_49, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_59]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 10] = [__v_54, __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(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 10] = [__v_53, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_55]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_57: G = { let __values: [G; 10] = [__v_52, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_58: G = { let __values: [G; 10] = [__v_51, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_57]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_59: G = { let __values: [G; 10] = [__v_50, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_58]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_60: G = { let __values: [G; 10] = [__v_49, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_59]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_87] = [__v_60]; record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7032,12 +7188,13 @@ fn aiur_fn_88( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 7] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 7] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_88] = [__v_4, __v_7, __v_0]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7103,11 +7260,12 @@ fn aiur_fn_88( let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 7] = [__v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_58]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = { let __values: [G; 7] = [__v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_58]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __ret: [G; OUT_88] = [__v_62, __v_63, __v_60]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7134,6 +7292,7 @@ fn aiur_fn_89( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_89] = [__v_3, __v_4, __v_2]; record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7146,6 +7305,7 @@ fn aiur_fn_89( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_89] = [__v_7, __v_5, __v_6]; record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7168,9 +7328,10 @@ fn aiur_fn_90( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_90] = [__v_4, __v_0]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7187,17 +7348,19 @@ fn aiur_fn_90( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_90] = [__v_11, __v_7]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_90] = [__v_10, __v_7]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7303,16 +7466,17 @@ fn aiur_fn_91( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_91] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70]; record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7361,11 +7525,12 @@ fn aiur_fn_92( let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 10] = [__v_28, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 10] = [__v_28, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_92] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_30, __v_20, __v_23, __v_24, __v_26, __v_27]; record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7389,12 +7554,13 @@ fn aiur_fn_93( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_93] = [__v_12]; record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7460,6 +7626,7 @@ fn aiur_fn_94( let __v_40: G = __r_arr[0]; let __ret: [G; OUT_94] = [__v_40]; record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7508,6 +7675,7 @@ fn aiur_fn_95( let __v_31: G = inp[31]; let __ret: [G; OUT_95] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7530,6 +7698,7 @@ fn aiur_fn_96( 0u64 => { let __ret: [G; OUT_96] = [__v_3]; record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7540,11 +7709,12 @@ fn aiur_fn_96( let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0, __v_6, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_96] = [__v_11]; record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7744,9 +7914,10 @@ fn aiur_fn_97( match __v_75.as_canonical_u64() { 1u64 => { let __v_172: G = G::from_u64(0); - let __v_173: G = { let __values: [G; 34] = [__v_172, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_173: G = { let __values: [G; 34] = [__v_172, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_97] = [__v_173]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7807,14 +7978,15 @@ fn aiur_fn_97( let __v_222: G = __r_arr[5]; let __v_223: G = __r_arr[6]; let __v_224: G = __r_arr[7]; - let __v_225: G = { let __values: [G; 8] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_226: G = { let __values: [G; 32] = [__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, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_225: G = { let __values: [G; 8] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_226: G = { let __values: [G; 32] = [__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, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_227: G = G::from_u64(0); - let __v_228: G = { let __values: [G; 34] = [__v_227, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_228: G = { let __values: [G; 34] = [__v_227, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_205, __v_207, __v_208, __v_225, __v_226, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_229]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7824,11 +7996,12 @@ fn aiur_fn_97( let __v_175: G = (__v_2 - __v_174); let __v_176: G = G::from_u64(1); let __v_177: G = (__v_3 + __v_176); - let __v_178: G = { let __values: [G; 32] = [__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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_178: G = { let __values: [G; 32] = [__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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_173, __v_175, __v_177, __v_4, __v_178, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_179: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_179]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8005,14 +8178,16 @@ fn aiur_fn_97( let __v_153: G = __r_arr[29]; let __v_154: G = __r_arr[30]; let __v_155: G = __r_arr[31]; - let __v_156: G = { let __values: [G; 34] = [__v_17, __v_6, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_156: G = { let __values: [G; 34] = [__v_17, __v_6, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_97] = [__v_156]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8020,6 +8195,7 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8027,6 +8203,7 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8034,6 +8211,7 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8041,6 +8219,7 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8048,6 +8227,7 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8055,6 +8235,7 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8062,6 +8243,7 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8069,7 +8251,7 @@ fn aiur_fn_97( _ => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0, __v_1, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(64); @@ -8234,9 +8416,10 @@ fn aiur_fn_97( let __v_165: G = __r_arr[29]; let __v_166: G = __r_arr[30]; let __v_167: G = __r_arr[31]; - let __v_168: G = { let __values: [G; 34] = [__v_95, __v_6, __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, __v_163, __v_164, __v_165, __v_166, __v_167]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_168: G = { let __values: [G; 34] = [__v_95, __v_6, __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, __v_163, __v_164, __v_165, __v_166, __v_167]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_97] = [__v_168]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8299,11 +8482,11 @@ fn aiur_fn_98( 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; 8] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_45: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 8] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); - let __v_48: G = { let __values: [G; 34] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 34] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_1, __v_2, __v_35, __v_44, __v_45, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -8376,6 +8559,7 @@ fn aiur_fn_98( let __v_115: G = __r_arr[31]; let __ret: [G; OUT_98] = [__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]; record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8564,6 +8748,7 @@ fn aiur_fn_99( let __v_169: G = __r_arr[31]; let __ret: [G; OUT_99] = [__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_169]; record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8671,6 +8856,7 @@ fn aiur_fn_100( let __v_82: G = (__v_67 * __v_81); let __ret: [G; OUT_100] = [__v_82]; record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8787,6 +8973,7 @@ fn aiur_fn_101( let __v_96: G = __r_arr[31]; let __ret: [G; OUT_101] = [__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]; record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8825,6 +9012,7 @@ fn aiur_fn_101( let __v_96: G = __r_arr[31]; let __ret: [G; OUT_101] = [__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]; record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8852,6 +9040,7 @@ fn aiur_fn_102( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_102] = [__v_5]; record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8862,6 +9051,7 @@ fn aiur_fn_102( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_102] = [__v_7]; record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8869,6 +9059,7 @@ fn aiur_fn_102( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_102] = [__v_7]; record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8901,9 +9092,10 @@ fn aiur_fn_103( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_103] = [__v_8]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8921,6 +9113,7 @@ fn aiur_fn_103( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_103] = [__v_11]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8941,15 +9134,17 @@ fn aiur_fn_103( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_103] = [__v_21]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_103] = [__v_23]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9007,6 +9202,7 @@ fn aiur_fn_104( let __v_21: G = G::from_u64(1); let __ret: [G; OUT_104] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_11, __v_1, __v_21]; record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -9027,6 +9223,7 @@ fn aiur_fn_104( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9044,6 +9241,7 @@ fn aiur_fn_104( let __v_25: G = __r_arr[10]; let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9255,14 +9453,16 @@ fn aiur_fn_105( let __v_161: G = __r_arr[29]; let __v_162: G = __r_arr[30]; let __v_163: G = __r_arr[31]; - let __v_164: G = { let __values: [G; 34] = [__v_25, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_164: G = { let __values: [G; 34] = [__v_25, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_105] = [__v_164]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9270,6 +9470,7 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9277,6 +9478,7 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9284,6 +9486,7 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9291,6 +9494,7 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9298,6 +9502,7 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9305,6 +9510,7 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9312,6 +9518,7 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9548,9 +9755,10 @@ fn aiur_fn_105( match __v_113.as_canonical_u64() { 1u64 => { let __v_209: G = G::from_u64(0); - let __v_210: G = { let __values: [G; 34] = [__v_209, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_210: G = { let __values: [G; 34] = [__v_209, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_105] = [__v_210]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9607,24 +9815,26 @@ fn aiur_fn_105( let __v_255: G = __r_arr[5]; let __v_256: G = __r_arr[6]; let __v_257: G = __r_arr[7]; - let __v_258: G = { let __values: [G; 8] = [__v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_259: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_258: G = { let __values: [G; 8] = [__v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_259: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_260: G = G::from_u64(0); - let __v_261: G = { let __values: [G; 34] = [__v_260, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_261: G = { let __values: [G; 34] = [__v_260, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_91, __v_92, __v_241, __v_258, __v_259, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_262]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_209: G = G::from_u64(1); let __v_210: G = (__v_2 + __v_209); - let __v_211: G = { let __values: [G; 32] = [__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_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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_211: G = { let __values: [G; 32] = [__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_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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_91, __v_92, __v_210, __v_3, __v_211, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_212: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_212]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9680,7 +9890,7 @@ fn aiur_fn_106( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __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); @@ -9690,11 +9900,11 @@ fn aiur_fn_106( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -9767,6 +9977,7 @@ fn aiur_fn_106( let __v_116: G = __r_arr[31]; let __ret: [G; OUT_106] = [__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]; record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -9854,6 +10065,7 @@ fn aiur_fn_107( let __v_67: G = __r_arr[31]; let __ret: [G; OUT_107] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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]; record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -9909,6 +10121,7 @@ fn aiur_fn_108( 0u64 => { let __ret: [G; OUT_108] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9980,6 +10193,7 @@ fn aiur_fn_108( let __v_99: G = __r_arr[31]; let __ret: [G; OUT_108] = [__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]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10006,6 +10220,7 @@ fn aiur_fn_109( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_109] = [__v_4]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10016,6 +10231,7 @@ fn aiur_fn_109( let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_109] = [__v_7]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10113,6 +10329,7 @@ fn aiur_fn_110( let __v_71: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_71]; record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10226,6 +10443,7 @@ fn aiur_fn_110( let __v_172: G = __r_arr[32]; let __ret: [G; OUT_110] = [__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_169, __v_170, __v_171, __v_172]; record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10326,6 +10544,7 @@ fn aiur_fn_111( let __v_71: G = __r_arr[32]; let __ret: [G; OUT_111] = [__v_39, __v_40, __v_41, __v_42, __v_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]; record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10417,6 +10636,7 @@ fn aiur_fn_112( let __v_71: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_71]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10441,15 +10661,17 @@ fn aiur_fn_113( 1u64 => { let __ret: [G; OUT_113] = [__v_1]; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10480,6 +10702,7 @@ fn aiur_fn_114( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10491,6 +10714,7 @@ fn aiur_fn_114( 0u64 => { let __ret: [G; OUT_114] = [__v_6]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10498,6 +10722,7 @@ fn aiur_fn_114( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_7]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10533,7 +10758,7 @@ fn aiur_fn_115( let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; @@ -10563,6 +10788,7 @@ fn aiur_fn_115( let __v_31: G = __r_arr[1]; let __ret: [G; OUT_115] = [__v_30, __v_31]; record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10584,7 +10810,7 @@ fn aiur_fn_116( let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; @@ -10593,6 +10819,7 @@ fn aiur_fn_116( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_116] = [__v_9]; record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10623,9 +10850,10 @@ fn aiur_fn_117( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_117] = [__v_13]; record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10634,9 +10862,10 @@ fn aiur_fn_117( let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_117] = [__v_14]; record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10674,6 +10903,7 @@ fn aiur_fn_118( 1u64 => { let __ret: [G; OUT_118] = [__v_6, __v_7, __v_8, __v_9]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10707,6 +10937,7 @@ fn aiur_fn_118( let __v_31: G = __r_arr[3]; let __ret: [G; OUT_118] = [__v_28, __v_29, __v_30, __v_31]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10742,6 +10973,7 @@ fn aiur_fn_119( 1u64 => { let __ret: [G; OUT_119] = [__v_1]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10771,6 +11003,7 @@ fn aiur_fn_119( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_119] = [__v_24]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10800,6 +11033,7 @@ fn aiur_fn_120( 1u64 => { let __ret: [G; OUT_120] = [__v_1]; record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10809,6 +11043,7 @@ fn aiur_fn_120( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_6]; record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10838,6 +11073,7 @@ fn aiur_fn_121( 1u64 => { let __ret: [G; OUT_121] = [__v_1]; record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10847,6 +11083,7 @@ fn aiur_fn_121( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_6]; record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10873,6 +11110,7 @@ fn aiur_fn_122( 0u64 => { let __ret: [G; OUT_122] = [__v_2]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -10880,6 +11118,7 @@ fn aiur_fn_122( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_122] = [__v_3]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10909,6 +11148,7 @@ fn aiur_fn_123( 1u64 => { let __ret: [G; OUT_123] = [__v_0]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10926,6 +11166,7 @@ fn aiur_fn_123( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_14]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10959,9 +11200,10 @@ fn aiur_fn_124( 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_124] = [__v_0, __v_12]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10969,7 +11211,7 @@ fn aiur_fn_124( let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; @@ -10982,6 +11224,7 @@ fn aiur_fn_124( } let __ret: [G; OUT_124] = [__v_15, __v_16]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11010,9 +11253,10 @@ fn aiur_fn_125( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_125] = [__v_9, __v_0]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11061,9 +11305,10 @@ fn aiur_fn_125( let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_125] = [__v_43, __v_39]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11098,6 +11343,7 @@ fn aiur_fn_126( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_126] = [__v_5]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11111,6 +11357,7 @@ fn aiur_fn_126( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_126] = [__v_9]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11122,6 +11369,7 @@ fn aiur_fn_126( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_13]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11148,9 +11396,10 @@ fn aiur_fn_127( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_127] = [__v_6]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11165,6 +11414,7 @@ fn aiur_fn_127( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_8]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11177,9 +11427,10 @@ fn aiur_fn_127( let __v_12: G = (__v_3 - __v_11); let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_127] = [__v_14]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11218,9 +11469,10 @@ fn aiur_fn_128( 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_128] = [__v_17]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11236,18 +11488,20 @@ fn aiur_fn_128( let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 7] = [__v_21, __v_9, __v_19, __v_20, __v_17, __v_18, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 7] = [__v_21, __v_9, __v_19, __v_20, __v_17, __v_18, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_128] = [__v_22]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_128] = [__v_19]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11286,6 +11540,7 @@ fn aiur_fn_129( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_129] = [__v_9]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11306,6 +11561,7 @@ fn aiur_fn_129( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_129] = [__v_15]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11313,6 +11569,7 @@ fn aiur_fn_129( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_129] = [__v_11]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11343,12 +11600,14 @@ fn aiur_fn_130( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_130] = [__v_2]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_130] = [__v_2]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11404,6 +11663,7 @@ fn aiur_fn_131( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_23]; record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11447,6 +11707,7 @@ fn aiur_fn_132( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_20]; record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11478,6 +11739,7 @@ fn aiur_fn_133( 0u64 => { let __ret: [G; OUT_133] = [__v_0]; record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11500,6 +11762,7 @@ fn aiur_fn_133( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_23]; record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11533,6 +11796,7 @@ fn aiur_fn_134( 0u64 => { let __ret: [G; OUT_134] = [__v_0]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11558,6 +11822,7 @@ fn aiur_fn_134( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_25]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11593,6 +11858,7 @@ fn aiur_fn_135( 0u64 => { let __ret: [G; OUT_135] = [__v_0]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11609,6 +11875,7 @@ fn aiur_fn_135( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_21]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -11633,6 +11900,7 @@ fn aiur_fn_135( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_29]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11673,6 +11941,7 @@ fn aiur_fn_136( 0u64 => { let __ret: [G; OUT_136] = [__v_0]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -11712,6 +11981,7 @@ fn aiur_fn_136( let __v_32: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_32]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11741,9 +12011,10 @@ fn aiur_fn_137( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_137] = [__v_6]; record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11757,9 +12028,10 @@ fn aiur_fn_137( let __v_10: G = (__v_3 + __v_9); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_137] = [__v_12]; record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11786,6 +12058,7 @@ fn aiur_fn_138( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_138] = [__v_4]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11796,11 +12069,13 @@ fn aiur_fn_138( 0u64 => { let __ret: [G; OUT_138] = [__v_4]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_138] = [__v_2]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11831,9 +12106,10 @@ fn aiur_fn_139( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_139] = [__v_7]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11850,6 +12126,7 @@ fn aiur_fn_139( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_11]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -11863,9 +12140,10 @@ fn aiur_fn_139( let __v_13: G = (__v_4 + __v_12); let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_139] = [__v_15]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11896,11 +12174,13 @@ fn aiur_fn_140( 0u64 => { let __ret: [G; OUT_140] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_140] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11963,13 +12243,14 @@ fn aiur_fn_141( let __v_39: G = __r_arr[7]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 10] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_45: G = { let __values: [G; 10] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_44]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 10] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 10] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_44]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_141] = [__v_46]; record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12002,6 +12283,7 @@ fn aiur_fn_142( 1u64 => { let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12023,11 +12305,13 @@ fn aiur_fn_142( let __v_21: G = __r_arr[1]; let __ret: [G; OUT_142] = [__v_20, __v_21, __v_12]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12082,6 +12366,7 @@ fn aiur_fn_143( } let __ret: [G; OUT_143] = [__v_0, __v_1]; record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12135,13 +12420,13 @@ fn aiur_fn_143( let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 3] = [__v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_50: G = { let __values: [G; 3] = [__v_46, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_46, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_19, __v_45, __v_50, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(1); @@ -12153,6 +12438,7 @@ fn aiur_fn_143( let __v_54: G = __r_arr[1]; let __ret: [G; OUT_143] = [__v_53, __v_54]; record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12354,6 +12640,7 @@ fn aiur_fn_144( let __v_95: G = G::from_u64(1); let __ret: [G; OUT_144] = [__v_95]; record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12418,6 +12705,7 @@ fn aiur_fn_145( let __v_29: G = G::from_u64(1); let __ret: [G; OUT_145] = [__v_29]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12431,6 +12719,7 @@ fn aiur_fn_145( let __v_33: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_33]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12487,7 +12776,7 @@ fn aiur_fn_146( let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(1); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; @@ -12500,7 +12789,7 @@ fn aiur_fn_146( let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; @@ -12529,7 +12818,7 @@ fn aiur_fn_146( let __v_64: G = __r_arr[1]; let __v_65: G = G::from_u64(1); let __v_66: G = G::from_u64(1); - let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_64, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; @@ -12566,6 +12855,7 @@ fn aiur_fn_146( let __v_84: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_84]; record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12589,6 +12879,7 @@ fn aiur_fn_147( let __v_4: G = (__v_2 * __v_3); let __ret: [G; OUT_147] = [__v_4]; record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12614,6 +12905,7 @@ fn aiur_fn_148( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_148] = [__v_5]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12628,6 +12920,7 @@ fn aiur_fn_148( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_9]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12635,6 +12928,7 @@ fn aiur_fn_148( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_9]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12673,16 +12967,17 @@ fn aiur_fn_149( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_149] = [__v_24]; record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12740,6 +13035,7 @@ fn aiur_fn_150( let __v_36: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_36]; record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12795,6 +13091,7 @@ fn aiur_fn_151( 1u64 => { let __ret: [G; OUT_151] = [__v_1]; record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12804,6 +13101,7 @@ fn aiur_fn_151( let __v_37: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_37]; record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12833,6 +13131,7 @@ fn aiur_fn_152( 1u64 => { let __ret: [G; OUT_152] = [__v_1]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12849,6 +13148,7 @@ fn aiur_fn_152( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_152] = [__v_13]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12878,6 +13178,7 @@ fn aiur_fn_153( 0u64 => { let __ret: [G; OUT_153] = [__v_3, __v_0, __v_4]; record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -12916,12 +13217,12 @@ fn aiur_fn_153( let __v_36: G = __r_arr[31]; let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_44: 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_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -12932,6 +13233,7 @@ fn aiur_fn_153( 0u64 => { let __ret: [G; OUT_153] = [__v_46, __v_40, __v_47]; record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12992,6 +13294,7 @@ fn aiur_fn_154( let __v_25: G = __r_arr[2]; let __ret: [G; OUT_154] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_24, __v_25]; record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13025,6 +13328,7 @@ fn aiur_fn_155( 1u64 => { let __ret: [G; OUT_155] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13041,6 +13345,7 @@ fn aiur_fn_155( let __v_22: G = __r_arr[9]; let __ret: [G; OUT_155] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13083,6 +13388,7 @@ fn aiur_fn_156( let __v_21: G = __r_arr[9]; let __ret: [G; OUT_156] = [__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[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13179,7 +13485,7 @@ fn aiur_fn_157( let __v_71: G = __b1_out[7]; let __v_72: G = G::from_u64(1); let __v_73: G = G::from_u64(1); - let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; @@ -13198,6 +13504,7 @@ fn aiur_fn_157( let __v_82: G = __r_arr[0]; let __ret: [G; OUT_157] = [__v_82]; record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13218,9 +13525,10 @@ fn aiur_fn_158( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_158] = [__v_4]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13235,9 +13543,10 @@ fn aiur_fn_158( let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_158] = [__v_9]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13279,6 +13588,7 @@ fn aiur_fn_159( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_159] = [__v_14, __v_11, __v_12]; record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13304,13 +13614,14 @@ fn aiur_fn_160( let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_160] = [__v_13]; record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13329,13 +13640,14 @@ fn aiur_fn_161( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_161] = [__v_6]; record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13367,6 +13679,7 @@ fn aiur_fn_162( 1u64 => { let __ret: [G; OUT_162] = [__v_1]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13376,6 +13689,7 @@ fn aiur_fn_162( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_13]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13405,6 +13719,7 @@ fn aiur_fn_163( 1u64 => { let __ret: [G; OUT_163] = [__v_1]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13425,6 +13740,7 @@ fn aiur_fn_163( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_163] = [__v_15]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13461,6 +13777,7 @@ fn aiur_fn_164( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13504,22 +13821,23 @@ fn aiur_fn_165( let __v_26: G = G::from_u64(118); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(48); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_165] = [__v_42]; record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13540,14 +13858,16 @@ fn aiur_fn_166( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_166] = [__v_4]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_166] = [__v_1]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13578,7 +13898,7 @@ fn aiur_fn_167( let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_6, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; @@ -13595,7 +13915,7 @@ fn aiur_fn_167( let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; @@ -13621,7 +13941,7 @@ fn aiur_fn_167( let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_41, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; @@ -13649,14 +13969,14 @@ fn aiur_fn_167( let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __v_67: G = G::from_u64(1); - let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_65, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); let __v_72: G = G::from_u64(1); - let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_70, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; @@ -13680,7 +14000,7 @@ fn aiur_fn_167( let __v_92: G = __r_arr[0]; let __v_93: G = G::from_u64(1); let __v_94: G = G::from_u64(1); - let __v_95: G = { let __values: [G; 3] = [__v_93, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_93, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_92, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; @@ -13718,6 +14038,7 @@ fn aiur_fn_167( let __v_121: G = __r_arr[0]; let __ret: [G; OUT_167] = [__v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_112]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13739,6 +14060,7 @@ fn aiur_fn_168( 0u64 => { let __ret: [G; OUT_168] = [__v_0, __v_1]; record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13752,6 +14074,7 @@ fn aiur_fn_168( let __v_8: G = __r_arr[1]; let __ret: [G; OUT_168] = [__v_7, __v_8]; record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13774,198 +14097,231 @@ fn aiur_fn_169( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(18446744069414584320); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(281474976710656); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(18446744069397807105); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(17293822564807737345); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(70368744161280); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(549755813888); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(17870292113338400769); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(13797081185216407910); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1803076106186727246); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(11353340290879379826); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(455906449640507599); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(17492915097719143606); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1532612707718625687); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16207902636198568418); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(17776499369601055404); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(6115771955107415310); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(12380578893860276750); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(9306717745644682924); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(18146160046829613826); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(3511170319078647661); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(17654865857378133588); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(5416168637041100469); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(16905767614792059275); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(9713644485405565297); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(5456943929260765144); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(17096174751763063430); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1213594585890690845); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(6414415596519834757); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(16116352524544190054); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(9123114210336311365); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(4614640910117430873); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13995,6 +14351,7 @@ fn aiur_fn_170( let __v_8: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_7, __v_8]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14015,6 +14372,7 @@ fn aiur_fn_171( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_171] = [__v_1]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14026,6 +14384,7 @@ fn aiur_fn_171( let __v_5: G = (__v_1 * __v_4); let __ret: [G; OUT_171] = [__v_5]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14076,6 +14435,7 @@ fn aiur_fn_172( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_172] = [__v_11, __v_12, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14146,6 +14506,7 @@ fn aiur_fn_173( let __v_31: G = G::from_u64(1); let __ret: [G; OUT_173] = [__v_31]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14176,6 +14537,7 @@ fn aiur_fn_174( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_174] = [__v_8, __v_9]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14204,6 +14566,7 @@ fn aiur_fn_175( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_175] = [__v_8, __v_9]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14228,9 +14591,10 @@ fn aiur_fn_176( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_176] = [__v_7]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14247,9 +14611,10 @@ fn aiur_fn_176( let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_176] = [__v_13]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14299,6 +14664,7 @@ fn aiur_fn_177( let __v_19: G = G::from_u64(0); let __ret: [G; OUT_177] = [__v_16, __v_19]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -14311,6 +14677,7 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -14319,6 +14686,7 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -14327,6 +14695,7 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -14335,6 +14704,7 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -14343,6 +14713,7 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14351,6 +14722,7 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14361,21 +14733,25 @@ fn aiur_fn_177( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_19, __v_20]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_177] = [__v_9, __v_10]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_177] = [__v_11, __v_12]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_177] = [__v_13, __v_14]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -14390,6 +14766,7 @@ fn aiur_fn_177( let __v_24: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_23, __v_24]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -14404,6 +14781,7 @@ fn aiur_fn_177( let __v_24: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_23, __v_24]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -14418,6 +14796,7 @@ fn aiur_fn_177( let __v_24: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_23, __v_24]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -14429,6 +14808,7 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14475,6 +14855,7 @@ fn aiur_fn_178( 1u64 => { let __ret: [G; OUT_178] = [__v_0, __v_1]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14489,6 +14870,7 @@ fn aiur_fn_178( let __v_27: G = __r_arr[1]; let __ret: [G; OUT_178] = [__v_26, __v_27]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14541,6 +14923,7 @@ fn aiur_fn_179( let __v_23: G = __r_arr[1]; let __ret: [G; OUT_179] = [__v_16, __v_17, __v_22, __v_23]; record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14586,6 +14969,7 @@ fn aiur_fn_180( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_180] = [__v_22, __v_23, __v_24, __v_25]; record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14607,6 +14991,7 @@ fn aiur_fn_180( let __v_33: G = __r_arr[1]; let __ret: [G; OUT_180] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14668,6 +15053,7 @@ fn aiur_fn_181( 1u64 => { let __ret: [G; OUT_181] = [__v_0, __v_1]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14766,6 +15152,7 @@ fn aiur_fn_181( let __v_79: G = __r_arr[1]; let __ret: [G; OUT_181] = [__v_78, __v_79]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14906,6 +15293,7 @@ fn aiur_fn_182( let __v_88: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_87, __v_88]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14917,6 +15305,7 @@ fn aiur_fn_182( let __v_68: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_67, __v_68]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14962,17 +15351,18 @@ fn aiur_fn_183( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_183] = [__v_34]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15003,6 +15393,7 @@ fn aiur_fn_184( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_184] = [__v_9, __v_10]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15020,6 +15411,7 @@ fn aiur_fn_184( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_184] = [__v_15, __v_16]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15045,114 +15437,133 @@ fn aiur_fn_185( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15177,12 +15588,13 @@ fn aiur_fn_186( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_186] = [__v_6, __v_9]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -15190,12 +15602,13 @@ fn aiur_fn_186( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_186] = [__v_6, __v_9]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -15209,6 +15622,7 @@ fn aiur_fn_186( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_186] = [__v_6, __v_8]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15266,6 +15680,7 @@ fn aiur_fn_187( let __v_27: G = G::from_u64(1); let __ret: [G; OUT_187] = [__v_27]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15359,6 +15774,7 @@ fn aiur_fn_187( let __v_80: G = __r_arr[0]; let __ret: [G; OUT_187] = [__v_80]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15400,6 +15816,7 @@ fn aiur_fn_188( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_188] = [__v_13, __v_14]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15417,6 +15834,7 @@ fn aiur_fn_188( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_188] = [__v_19, __v_20]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15451,6 +15869,7 @@ fn aiur_fn_189( 1u64 => { let __ret: [G; OUT_189] = [__v_0, __v_1]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15471,6 +15890,7 @@ fn aiur_fn_189( let __v_19: G = __r_arr[1]; let __ret: [G; OUT_189] = [__v_18, __v_19]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15590,6 +16010,7 @@ fn aiur_fn_190( let __v_67: G = __r_arr[0]; let __ret: [G; OUT_190] = [__v_67]; record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15622,6 +16043,7 @@ fn aiur_fn_191( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_191] = [__v_4]; record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15636,6 +16058,7 @@ fn aiur_fn_191( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_191] = [__v_8]; record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15669,9 +16092,10 @@ fn aiur_fn_192( 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 7] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 7] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_192] = [__v_11]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15687,15 +16111,17 @@ fn aiur_fn_192( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_192] = [__v_12]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 7] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 7] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_192] = [__v_14]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15733,9 +16159,10 @@ fn aiur_fn_193( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_193] = [__v_8]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15751,15 +16178,17 @@ fn aiur_fn_193( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_193] = [__v_9]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_193] = [__v_11]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15795,6 +16224,7 @@ fn aiur_fn_194( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_3, __v_4]; record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15815,9 +16245,10 @@ fn aiur_fn_195( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_195] = [__v_4, __v_0]; record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15830,9 +16261,10 @@ fn aiur_fn_195( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_195] = [__v_9, __v_7]; record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15858,6 +16290,7 @@ fn aiur_fn_196( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_3, __v_4]; record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15878,9 +16311,10 @@ fn aiur_fn_197( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_197] = [__v_4, __v_0]; record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15900,9 +16334,10 @@ fn aiur_fn_197( let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_197] = [__v_16, __v_14]; record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16405,6 +16840,7 @@ fn aiur_fn_198( } let __ret: [G; OUT_198] = []; record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16429,6 +16865,7 @@ fn aiur_fn_199( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_199] = [__v_4]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16438,6 +16875,7 @@ fn aiur_fn_199( let __v_6: G = (__v_4 + __v_5); let __ret: [G; OUT_199] = [__v_6]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16467,12 +16905,14 @@ fn aiur_fn_200( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_4]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_200] = [__v_4]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16505,6 +16945,7 @@ fn aiur_fn_201( 0u64 => { let __ret: [G; OUT_201] = [__v_4, __v_5]; record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16548,6 +16989,7 @@ fn aiur_fn_202( let __v_18: G = G::from_u64(0); let __ret: [G; OUT_202] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16571,6 +17013,7 @@ fn aiur_fn_202( let __v_26: G = __r_arr[7]; let __ret: [G; OUT_202] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16602,6 +17045,7 @@ fn aiur_fn_203( 0u64 => { let __ret: [G; OUT_203] = [__v_4]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16633,6 +17077,7 @@ fn aiur_fn_204( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_204] = [__v_6]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16642,6 +17087,7 @@ fn aiur_fn_204( let __v_8: G = (__v_6 + __v_7); let __ret: [G; OUT_204] = [__v_8]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16672,6 +17118,7 @@ fn aiur_fn_205( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_205] = [__v_5]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16681,6 +17128,7 @@ fn aiur_fn_205( let __v_7: G = (__v_5 + __v_6); let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16717,15 +17165,17 @@ fn aiur_fn_206( 1u64 => { let __ret: [G; OUT_206] = [__v_1]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_206] = [__v_14]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16762,6 +17212,7 @@ fn aiur_fn_207( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16785,6 +17236,7 @@ fn aiur_fn_207( let __v_19: G = __r_arr[7]; let __ret: [G; OUT_207] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16814,15 +17266,17 @@ fn aiur_fn_208( 1u64 => { let __ret: [G; OUT_208] = [__v_1]; record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; let __ret: [G; OUT_208] = [__v_7]; record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16848,6 +17302,7 @@ fn aiur_fn_209( 0u64 => { let __ret: [G; OUT_209] = [__v_0]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16863,6 +17318,7 @@ fn aiur_fn_209( 0u64 => { let __ret: [G; OUT_209] = [__v_7]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16898,6 +17354,7 @@ fn aiur_fn_210( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_210] = [__v_8]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16907,6 +17364,7 @@ fn aiur_fn_210( let __v_10: G = (__v_8 + __v_9); let __ret: [G; OUT_210] = [__v_10]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16943,6 +17401,7 @@ fn aiur_fn_211( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_211] = [__v_11]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16952,6 +17411,7 @@ fn aiur_fn_211( let __v_13: G = (__v_11 + __v_12); let __ret: [G; OUT_211] = [__v_13]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16986,6 +17446,7 @@ fn aiur_fn_212( 0u64 => { let __ret: [G; OUT_212] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17048,6 +17509,7 @@ fn aiur_fn_213( 0u64 => { let __ret: [G; OUT_213] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17073,6 +17535,7 @@ fn aiur_fn_214( 0u64 => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17089,6 +17552,7 @@ fn aiur_fn_214( 0u64 => { let __ret: [G; OUT_214] = [__v_8]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17116,6 +17580,7 @@ fn aiur_fn_215( 0u64 => { let __ret: [G; OUT_215] = [__v_0]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17134,6 +17599,7 @@ fn aiur_fn_215( 0u64 => { let __ret: [G; OUT_215] = [__v_10]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17161,6 +17627,7 @@ fn aiur_fn_216( 0u64 => { let __ret: [G; OUT_216] = [__v_0]; record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17207,6 +17674,7 @@ fn aiur_fn_216( 0u64 => { let __ret: [G; OUT_216] = [__v_38]; record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index 377172853..0cea47ca0 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -1258,6 +1258,78 @@ fn uncoarsen_refine( // Manifest // ============================================================================ +/// Planner cost of one shard, tagged by the metric it is denominated in. +/// All shards of one manifest carry the same variant (one packer, one +/// backend); the tag makes the unit explicit — cross-backend values can +/// never be compared by accident — and puts the heaviest-first prove +/// ordering in the manifest itself instead of a sidecar file. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)] +pub enum ShardCost { + /// No planner cost recorded. + #[default] + Unknown, + /// Sum of member kernel heartbeats — the balance metric of the + /// profile-driven min-cut partitioners. + ProfileHeartbeats(u64), + /// Zisk guest cost units (ziskemu `-X` TOTAL; see the calibrated cost + /// model below). + ZiskCostUnits(u64), + /// Aiur circuit FFT cost (raw `w·h·log2(h)` units, the same + /// denomination as the bench rows' `fft-cost` and the Lean stats + /// dump): MEASURED when produced by the env scan, model-predicted + /// when produced by the `.ixprof` packer. + AiurFft(u64), +} + +/// An FFT cost (raw `w·h·log2(h)` units, f64) as a saturating `u64`, +/// converted without a lossy `as` cast (decimal round-trip; cost +/// magnitudes sit far below any precision edge, and this only runs once +/// per shard at manifest-write time). +pub fn cost_fft(fft: f64) -> u64 { + format!("{:.0}", fft.max(0.0)).parse().unwrap_or(u64::MAX) +} + +impl ShardCost { + /// The scalar used for ordering and balance WITHIN one manifest; its + /// unit is whatever the variant says. + pub fn value(self) -> u64 { + match self { + Self::Unknown => 0, + Self::ProfileHeartbeats(v) | Self::ZiskCostUnits(v) + | Self::AiurFft(v) => v, + } + } + + /// Unit label for reports. + pub fn unit(self) -> &'static str { + match self { + Self::Unknown => "", + Self::ProfileHeartbeats(_) => "hb", + Self::ZiskCostUnits(_) => "cost-units", + Self::AiurFft(_) => "fft", + } + } + + fn tag(self) -> u8 { + match self { + Self::Unknown => 0, + Self::ProfileHeartbeats(_) => 1, + Self::ZiskCostUnits(_) => 2, + Self::AiurFft(_) => 3, + } + } + + fn from_tag(tag: u8, value: u64) -> Result { + match tag { + 0 => Ok(Self::Unknown), + 1 => Ok(Self::ProfileHeartbeats(value)), + 2 => Ok(Self::ZiskCostUnits(value)), + 3 => Ok(Self::AiurFft(value)), + t => Err(format!("unknown shard-cost tag {t}")), + } + } +} + /// Per-shard summary in a [`ShardManifest`]. #[derive(Clone, Debug, PartialEq, Eq)] pub struct ShardInfo { @@ -1265,8 +1337,8 @@ pub struct ShardInfo { pub id: u32, /// Member block addresses. pub blocks: Vec
, - /// Sum of member heartbeats (balance metric). - pub heartbeats: u64, + /// Planner cost (packing/balance metric, unit-tagged). + pub cost: ShardCost, /// Sum of member serialized sizes (the shard's own ingress). pub own_size: u64, /// Foreign blocks delta-unfolded by members but proven in other shards. @@ -1326,6 +1398,7 @@ impl ShardManifest { members[s].iter().map(|&b| profile.block(b).addr.clone()).collect(); let heartbeats: u64 = members[s].iter().map(|&b| profile.block(b).heartbeats).sum(); + let cost = ShardCost::ProfileHeartbeats(heartbeats); let own_size: u64 = members[s] .iter() .map(|&b| u64::from(profile.block(b).serialized_size)) @@ -1340,7 +1413,7 @@ impl ShardManifest { shards.push(ShardInfo { id: s as u32, blocks, - heartbeats, + cost, own_size, foreign_blocks, cross_ingress, @@ -1365,16 +1438,23 @@ impl ShardManifest { /// A human-readable what-if summary line. pub fn summary(&self) -> String { - let hbs: Vec = self.shards.iter().map(|s| s.heartbeats).collect(); + let costs: Vec = + self.shards.iter().map(|s| s.cost.value()).collect(); let nonempty: Vec = self .shards .iter() .filter(|s| !s.blocks.is_empty()) - .map(|s| s.heartbeats) + .map(|s| s.cost.value()) .collect(); - let max = hbs.iter().copied().max().unwrap_or(0); + let unit = self + .shards + .first() + .map(|s| s.cost.unit()) + .filter(|u| !u.is_empty()) + .unwrap_or("cost"); + let max = costs.iter().copied().max().unwrap_or(0); let min = nonempty.iter().copied().min().unwrap_or(0); - let total: u128 = hbs.iter().map(|&h| u128::from(h)).sum(); + let total: u128 = costs.iter().map(|&h| u128::from(h)).sum(); let mean = if self.shards.is_empty() { 0 } else { @@ -1384,7 +1464,7 @@ impl ShardManifest { let max_cross = self.shards.iter().map(|s| s.cross_ingress).max().unwrap_or(0); format!( - "shards={} (empty={}) heartbeats[min={} mean={} max={}] imbalance={:.2}x \ + "shards={} (empty={}) {unit}[min={} mean={} max={}] imbalance={:.2}x \ cross_ingress_total={} max_shard_cross={}", self.shards.len(), empty, @@ -1411,7 +1491,8 @@ impl ShardManifest { }; for sh in &self.shards { out.extend_from_slice(&sh.id.to_le_bytes()); - out.extend_from_slice(&sh.heartbeats.to_le_bytes()); + out.push(sh.cost.tag()); + out.extend_from_slice(&sh.cost.value().to_le_bytes()); out.extend_from_slice(&sh.own_size.to_le_bytes()); out.extend_from_slice(&sh.cross_ingress.to_le_bytes()); match &sh.assumption_root { @@ -1440,7 +1521,15 @@ impl ShardManifest { /// Deserialize from the `.ixes` binary format. pub fn from_bytes(bytes: &[u8]) -> Result { let mut c = Cur { buf: bytes, pos: 0 }; - if c.take(8)? != SHARD_MAGIC { + let magic = c.take(8)?; + if magic != SHARD_MAGIC { + if magic.starts_with(b"IXES") { + return Err(format!( + "unsupported .ixes format version {} (expected {}) — regenerate \ + the manifest with the current `ix shard`/`ix shard scan`", + magic[7], SHARD_MAGIC[7] + )); + } return Err("not an .ixes file (bad magic)".into()); } let total_cross_ingress = c.u128()?; @@ -1448,7 +1537,7 @@ impl ShardManifest { let mut shards = Vec::with_capacity(num_shards); for _ in 0..num_shards { let id = c.u32()?; - let heartbeats = c.u64()?; + let cost = ShardCost::from_tag(c.u8()?, c.u64()?)?; let own_size = c.u64()?; let cross_ingress = c.u64()?; let assumption_root = if c.u8()? == 1 { Some(c.addr()?) } else { None }; @@ -1457,7 +1546,7 @@ impl ShardManifest { shards.push(ShardInfo { id, blocks, - heartbeats, + cost, own_size, foreign_blocks, cross_ingress, @@ -1497,8 +1586,10 @@ impl ShardManifest { } } -/// Magic bytes at the head of every `.ixes` file. -const SHARD_MAGIC: &[u8; 8] = b"IXES\0\0\0\0"; +/// Magic bytes at the head of every `.ixes` file; the final byte is the +/// format version (bumped to 2 when per-shard tagged costs replaced the +/// bare heartbeats field). +const SHARD_MAGIC: &[u8; 8] = b"IXES\0\0\0\x02"; /// Minimal little-endian cursor for manifest decoding. struct Cur<'a> { @@ -1580,7 +1671,7 @@ pub fn shard_esp( let max_block_hb = profile.blocks().iter().map(|b| b.heartbeats).max().unwrap_or(0); let max_shard_hb = - manifest.shards.iter().map(|s| s.heartbeats).max().unwrap_or(0); + manifest.shards.iter().map(|s| s.cost.value()).max().unwrap_or(0); let floored = num_shards > 1 && max_shard_hb <= max_block_hb.saturating_mul(11) / 10; let note = if floored { @@ -1677,9 +1768,14 @@ pub fn shard_esp_aiur( let mut manifest = ShardManifest::build(&profile, &plan.shard_of, plan.num_shards) .with_tree(plan.tree); - for shard in &mut manifest.shards { + for (shard, c) in manifest.shards.iter_mut().zip(&plan.shard_costs) { shard.assumption_root = ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); + shard.cost = ShardCost::AiurFft(cost_fft(aiur_shard_fft( + c.union_bytes, + c.subst, + c.def_eq, + ))); } if let Some(op) = out_path { std::fs::write(op, manifest.to_bytes()) @@ -1962,12 +2058,12 @@ pub fn rebudget_manifest_shard( (0..n_children - 1).map(|i| (old_n + i) as u32).collect(); rebuilt.tree = manifest.tree.as_ref().map(|t| patch_tree(t, shard_k as u32, &extra_ids)); - std::fs::write(out_path, rebuilt.to_bytes()) - .map_err(|e| format!("write {out_path}: {e}"))?; // Costs sidecar: recompute every row's faulted-set union from the profile // (identical to the input rows for untouched shards — the union is a - // function of the owned set alone). + // function of the owned set alone). Untouched shards keep the INPUT + // manifest's cost (a scan's measured fft survives a rebudget of a + // sibling); children get the model prediction. let measured = profile.has_touch_graph(); let mut csv = String::from( "shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,\ @@ -1975,9 +2071,12 @@ pub fn rebudget_manifest_shard( ); let mut report = String::new(); let mut union_set: FxHashSet = FxHashSet::default(); - for (i, sh) in rebuilt.shards.iter().enumerate() { - let ids: Vec = - sh.blocks.iter().map(&to_id).collect::>()?; + for i in 0..rebuilt.shards.len() { + let ids: Vec = rebuilt.shards[i] + .blocks + .iter() + .map(&to_id) + .collect::>()?; union_set.clear(); for &b in &ids { union_set.insert(b); @@ -1999,18 +2098,26 @@ pub fn rebudget_manifest_shard( .map(|&b| u64::from(profile.block(b).serialized_size)) .sum(); let sum = |f: &dyn Fn(u32) -> u64| ids.iter().map(|&b| f(b)).sum::(); - let hb = sh.heartbeats; let subst = sum(&|b| profile.block(b).subst); let subst_unique = sum(&|b| profile.block(b).subst_unique); let whnf = sum(&|b| profile.block(b).whnf); let def_eq = sum(&|b| profile.block(b).def_eq); let nat_arith = sum(&|b| profile.block(b).nat_arith); let ram = aiur_ram_gib(union_bytes, subst, def_eq); + rebuilt.shards[i].cost = if i != shard_k && i < old_n { + manifest.shards[i].cost + } else { + ShardCost::AiurFft(cost_fft(aiur_shard_fft( + union_bytes, + subst, + def_eq, + ))) + }; csv.push_str(&format!( "{},{},{},{},{},{},{},{},{:.2},{:.2}\n", i, union_bytes, - hb, + rebuilt.shards[i].cost.value(), subst, subst_unique, whnf, @@ -2022,11 +2129,13 @@ pub fn rebudget_manifest_shard( if i == shard_k || i >= old_n { report.push_str(&format!( " child shard {i}: {} blocks, union {:.1} MB, pred_ram {ram:.2} GiB\n", - sh.blocks.len(), + rebuilt.shards[i].blocks.len(), union_bytes as f64 / 1e6, )); } } + std::fs::write(out_path, rebuilt.to_bytes()) + .map_err(|e| format!("write {out_path}: {e}"))?; let cp = format!("{out_path}.costs.csv"); std::fs::write(&cp, csv).map_err(|e| format!("write {cp}: {e}"))?; @@ -2835,7 +2944,7 @@ pub fn partition_for_aiur_ram( /// shard. `pieces` is the requested fine-partition size (~[`PACK_PIECES_PER_CAP`] /// per cap, in the caller's cost unit), bounded by the block count; when /// everything fits one cap this collapses to the trivial order. -fn cut_coherent_order( +pub fn cut_coherent_order( profile: &BlockProfile, pieces: usize, epsilon: f64, @@ -2870,7 +2979,7 @@ fn dfs_leaf_order(node: &AggNode, out: &mut Vec) { } /// A balanced binary [`AggNode`] over the contiguous shard-id range `lo..hi`. -fn balanced_agg_tree(lo: u32, hi: u32) -> AggNode { +pub fn balanced_agg_tree(lo: u32, hi: u32) -> AggNode { debug_assert!(hi > lo); if hi - lo <= 1 { AggNode::Leaf(lo) @@ -2959,8 +3068,8 @@ mod tests { let m = ShardManifest::build(&p, &shard_of, 2); assert_eq!(m.shards.len(), 2); // Each cluster has 3 blocks × 100 heartbeats = 300; perfectly balanced. - assert_eq!(m.shards[0].heartbeats, 300); - assert_eq!(m.shards[1].heartbeats, 300); + assert_eq!(m.shards[0].cost, ShardCost::ProfileHeartbeats(300)); + assert_eq!(m.shards[1].cost, ShardCost::ProfileHeartbeats(300)); } #[test] @@ -2986,7 +3095,7 @@ mod tests { assert_eq!(m.total_cross_ingress, 0); // Each non-empty shard should hold exactly one cluster (4×100). for s in &m.shards { - assert_eq!(s.heartbeats, 400); + assert_eq!(s.cost, ShardCost::ProfileHeartbeats(400)); } } From f5bab27feee93b97f5963ade794f6fc56411d947 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Wed, 5 Aug 2026 14:29:28 +0000 Subject: [PATCH 08/20] =?UTF-8?q?shard=20scan:=20batched=20measurement=20c?= =?UTF-8?q?laims=20=E2=80=94=20one=20CheckEnv=20per=20128=20blocks?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The claim layer's per-claim costs (in-circuit assumption-tree hashing, env_walk frames never memo-shared across claims, members assumed by one claim then checked by the next) inflated the incremental readout ~25% per-block, which forced a blanket re-price pass doubling scan wall. Batching divides that overhead by the batch size and removes intra-batch frontier edges entirely; measured drift of the running readout vs one-cold-claim re-priced costs on Init: K=16 +11.6%, K=64 +3.7%, K=128 +0.9% — within the cut's ε margin, so the readout serves directly as the manifest cost and the blanket re-price reverts to merged-only. Any batch-level event needing per-block attribution — the segment's first claim crossing the cut, a kernel reject, a record-cap trip with nothing banked — ends the segment at the last clean checkpoint and re-enters that batch through a NARROW window, one block per claim, where the single-block semantics apply verbatim: a lone block over the cut is emitted alone with its measured cost, a rejected or over-cap block is named and skipped. A remainder re-queued mid-window rediscovers the event deterministically, so partitions stay scheduling-independent. IX_SCAN_BATCH_BLOCKS overrides the batch size (1 restores per-block claims). Validated at 250 GiB (vs the re-priced pipeline): Init 40 shards / 1,734 BFFT in 86 s (was 40 / 1,719 / 152 s); InitStd 76 / 3,269 / 130 s (was 76 / 3,330 / 255 s); Lean 90 / 5,171 / 206 s (was 108 / 5,086 / 383 s) — ~45% less wall, and Lean packs 17% fewer shards because cut placement now sees near-true running costs instead of inflated ones. ixvm suite green. --- crates/ffi/src/aiur/scan.rs | 189 ++++++++++++++++++++++++------------ 1 file changed, 125 insertions(+), 64 deletions(-) diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index 55ba18c34..70bc5fc9b 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -9,18 +9,21 @@ //! circuit work by a content-dependent factor cannot occur. //! //! The measurement unit is the SAME claim the prover pays for: a -//! thin-frontier `CheckEnv` over a prefix of the schedule. Each segment -//! grows its owned prefix adaptively — execute `CheckEnv[lo..lo+k]` against -//! a shared `QueryRecord`, checkpoint the FFT, grow `k` while under the -//! cut — so every constant is checked once per segment and dependencies -//! stop at the assumed frontier. (Per-constant `Check{assumptions: None}` -//! claims are NOT usable here: without a frontier the kernel checks the -//! constant's whole dependency closure, which measures 100-1000× the real -//! per-block shard cost and rederives the env spine per segment.) The -//! grown record over-counts slightly — each growth step re-walks its -//! claim's owned/assumption trees, and members assumed at step `i` may be -//! checked at step `i+1` — so the checkpoint is a mild upper bound on the -//! emitted shard's cold cost: the safe direction for packing. +//! thin-frontier `CheckEnv`, one per BATCH of schedule blocks. Each +//! segment grows batch by batch — execute the batch's claim against a +//! shared `QueryRecord`, checkpoint (fft, record bytes), continue while +//! under the cut — so every constant is checked once per segment and +//! dependencies stop at the assumed frontier. (Per-constant +//! `Check{assumptions: None}` claims are NOT usable here: without a +//! frontier the kernel checks the constant's whole dependency closure, +//! which measures 100-1000× the real per-block shard cost and rederives +//! the env spine per segment.) The shared record over-counts slightly — +//! each claim walks its own owned/assumption trees, and members assumed +//! by one claim may be checked by the next — but batching divides that +//! per-claim overhead by the batch size and removes intra-batch frontier +//! edges entirely, so the checkpoint is a tight upper bound on the +//! emitted shard's cold cost: the safe direction for packing, accurate +//! enough to BE the manifest cost without a blanket re-price. //! //! Witness bytes are served LAZILY (`EnvFaultSource`): only the claim //! wires are seeded per attempt, and constant/hint/blob bytes materialize @@ -250,8 +253,23 @@ struct ScanCtx<'a> { /// far beyond any single-shard budget. (`--workers 1` grants one worker /// the whole allowance when such a block must be measured anyway.) seg_byte_budget: usize, + /// Blocks per measurement claim. Batching divides the claim layer's + /// per-claim overhead (assumption-tree hashing, unshared `env_walk` + /// frames) by K and shrinks frontiers (intra-batch edges stop being + /// frontier members), keeping the running readout tight enough to + /// serve as the shard cost without a blanket re-price. + batch_blocks: usize, } +/// Default blocks per measurement claim; `IX_SCAN_BATCH_BLOCKS` +/// overrides (1 restores per-block claims). Fixed — never adaptive — so +/// the partition stays independent of scheduling. Sized from the +/// measured inflation curve on Init (drift vs one-cold-claim re-priced +/// costs: K=16 +11.6%, K=64 +3.7%, K=128 +0.9%): at 128 the running +/// readout is within the cut's ε margin, so it serves directly as the +/// manifest cost. +const SCAN_BATCH_BLOCKS: usize = 128; + /// Smallest useful per-worker record cap, GiB. Typical segments at any /// realistic cut carry 3–8 GiB of record (measured 4–10% of the combined /// cut across envs), so a cap at this floor still lets normal segments @@ -317,11 +335,16 @@ pub fn scan_shards( } let env_bytes: u64 = blocks.iter().map(|b| b.size).sum(); let (workers, seg_budget_gib) = fleet_plan(workers, cut_used_gib); + let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") + .ok() + .and_then(|v| v.parse::().ok()) + .filter(|&k| k >= 1) + .unwrap_or(SCAN_BATCH_BLOCKS); let n_chunks = (workers * 2).min(blocks.len()); eprintln!( "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut {:.1} \ GiB combined (≈{:.1} BFFT fft-only), {seg_budget_gib:.1} GiB record \ - cap per worker", + cap per worker, {batch_blocks} blocks per claim", blocks.len(), cut_used_gib, cut_fft / 1e9 @@ -389,6 +412,7 @@ pub fn scan_shards( failed: &failed, abort: &abort, seg_byte_budget: gib_to_bytes(seg_budget_gib), + batch_blocks, }; type Range = (u32, u32, Vec); let queue: Mutex> = Mutex::new( @@ -474,15 +498,12 @@ pub fn scan_shards( // merges. This is what lets the chunk count scale with workers without // fragmenting the pack or corrupting the cost sidecar. let pre_merge = segments.len(); - // EVERY segment starts dirty: the incremental scan's running readout - // carries per-block claim inflation (env_walk re-runs per claim), so - // each shard is re-priced once with the single cold thin-frontier - // CheckEnv a prove of it actually executes. Merging then compares true - // costs — without this, inflated sums block consolidation and the - // sidecar over-states prove RSS. (Re-measures run `workers`-wide; a - // shard's record is bounded by the cut, so the fleet bound holds.) + // Batched claims keep the running readout within a couple percent of + // the cold cost (per-claim overhead divided by the batch size), so + // only MERGED shards need a re-measure — their summed costs are the + // one remaining conservative estimate. let mut list: Vec<(Segment, bool)> = - segments.into_iter().map(|s| (s, true)).collect(); + segments.into_iter().map(|s| (s, false)).collect(); for round in 0usize.. { let used = |sg: &Segment| AIUR_RAM_GIB_PER_BFFT * sg.fft / 1e9 + sg.bytes_gib; @@ -689,21 +710,29 @@ fn measure_shard( /// back on the queue for any idle worker. const RANGE_SEGMENTS: usize = 2; -/// Scan one range: execute per-block thin-frontier `CheckEnv` claims -/// against a shared record and lazily-faulted witness, checkpointing the -/// running FFT after every block and cutting on the exact block boundary -/// where it reaches the cut (the crossing block re-executes as the next -/// segment's first block, so an emitted shard never exceeds the cut — -/// except a single atomically-infeasible block, emitted alone with its -/// measured cost). One claim per block costs ~1ms of plumbing (measured) -/// plus a small per-block assumption-tree inflation that only steers cut -/// placement — the merge + re-measure pass re-prices every shard with -/// ONE real claim — and in exchange the scan is preemptible at BLOCK -/// granularity: no growth attempts, no overshoot re-execution, no cold -/// restarts, and RAM shedding or work-stealing acts between any two -/// blocks instead of stalling behind a multi-minute claim execution. +/// Scan one range: execute thin-frontier `CheckEnv` claims — one per +/// BATCH of [`ScanCtx::batch_blocks`] blocks — against a shared record +/// and lazily-faulted witness, checkpointing the running (fft, record +/// bytes) after every claim and cutting on the batch boundary where it +/// reaches the cut (the crossing batch re-executes as the next segment's +/// first claim, so an emitted shard never exceeds the cut). Batching is +/// what keeps the running readout honest: the claim layer's per-claim +/// costs (in-circuit assumption-tree hashing, `env_walk` frames that are +/// never memo-shared across claims, members assumed by one claim then +/// checked by the next) shrink ~K-fold, and intra-batch edges stop being +/// frontier members entirely, so the checkpoint stays a tight upper +/// bound on the emitted shard's cold cost without a blanket re-price. +/// +/// Any batch-level event that needs per-block attribution — the segment's +/// FIRST claim crossing the cut, a kernel reject, or a record-cap trip +/// with nothing banked — ends the segment at the last clean checkpoint +/// (the polluted record is dropped) and re-enters that batch through a +/// NARROW window, one block per claim, where the single-block semantics +/// apply verbatim: a lone block over the cut is emitted alone with its +/// measured cost, a rejected or over-cap block is named and skipped. /// Emits at most [`RANGE_SEGMENTS`] segments, then returns the remaining -/// blocks for any idle worker. +/// blocks for any idle worker; a remainder re-queued mid-window simply +/// rediscovers the event deterministically. fn scan_range( ctx: &ScanCtx<'_>, chunk: &[u32], @@ -714,6 +743,10 @@ fn scan_range( let n_chunks = ctx.n_chunks; let mut segments: Vec = Vec::new(); let mut lo = 0usize; + // Blocks below this index (and at/after `lo`) execute one per claim: + // a batch-level event landed in [lo, narrow_until) and needs per-block + // attribution. Stale values (< hi) are inert. + let mut narrow_until = 0usize; while lo < chunk.len() && segments.len() < RANGE_SEGMENTS { let mut record = QueryRecord::new(ctx.toplevel); // Arm the per-worker record cap for this fresh record. Worker threads @@ -732,37 +765,55 @@ fn scan_range( if ctx.abort.load(Ordering::Acquire) { return Err("aborted after a failure elsewhere".to_string()); } - let addr = ctx.blocks[chunk[hi] as usize].addr.clone(); - // `Err(None)` = the record cap tripped mid-block (not a kernel - // verdict); `Err(Some(e))` = the kernel rejected the block. - let out: Result<(), Option> = seed_shard_check_env_claim( - ctx.env, - std::slice::from_ref(&addr), - &mut io, - ) - .map_err(Some) - .and_then(|(_claim, input)| { - execute_ixvm_with_record( - ctx.toplevel, - ctx.fun_idx, - &input, - &mut io, - &mut record, - ) - .map(|_| ()) - .map_err(|e| match e { - ExecError::RecordBudgetExceeded => None, - other => Some(other.to_string()), - }) - }); - // A cap trip on a segment that already holds blocks is an early - // cut, not a failure: cut at the previous block; the crossing - // block restarts the next segment with a fresh record and full - // cap, and only counts as over-cap if it then trips ALONE. + let k = if hi < narrow_until { + 1 + } else { + ctx.batch_blocks.min(chunk.len() - hi) + }; + let addrs: Vec
= chunk[hi..hi + k] + .iter() + .map(|&b| ctx.blocks[b as usize].addr.clone()) + .collect(); + // `Err(None)` = the record cap tripped mid-claim (not a kernel + // verdict); `Err(Some(e))` = the kernel rejected a block. + let out: Result<(), Option> = + seed_shard_check_env_claim(ctx.env, &addrs, &mut io) + .map_err(Some) + .and_then(|(_claim, input)| { + execute_ixvm_with_record( + ctx.toplevel, + ctx.fun_idx, + &input, + &mut io, + &mut record, + ) + .map(|_| ()) + .map_err(|e| match e { + ExecError::RecordBudgetExceeded => None, + other => Some(other.to_string()), + }) + }); + // A cap trip on a segment that already holds claims is an early + // cut, not a failure: cut at the previous checkpoint; the crossing + // batch restarts the next segment with a fresh record and full + // cap, and only narrows if it then trips with nothing banked. if matches!(out, Err(None)) && hi > lo { break (hi, prev_fft, prev_bytes); } if let Err(err) = out { + if k > 1 { + // Per-block attribution needed: end the segment at the last + // clean checkpoint (dropping the polluted record) and rescan + // this batch one block per claim. + eprintln!( + "[scan {chunk_id}/{n_chunks}] narrowing batch at block \ + {hi}: {}", + err.as_deref().unwrap_or("record cap crossed") + ); + narrow_until = hi + k; + break (hi, prev_fft, prev_bytes); + } + let addr = &addrs[0]; let e = err.unwrap_or_else(|| { format!( "record bytes crossed the {:.1} GiB per-worker cap alone — \ @@ -785,7 +836,7 @@ fn scan_range( "[scan {chunk_id}/{n_chunks}] SKIPPING block {}: {e}", addr.hex() ); - ctx.failed.lock().unwrap().push((addr, e)); + ctx.failed.lock().unwrap().push((addr.clone(), e)); skip_failed = true; break (hi, prev_fft, prev_bytes); } @@ -794,13 +845,23 @@ fn scan_range( let used = AIUR_RAM_GIB_PER_BFFT * fft / 1e9 + bytes_gib; if used >= ctx.cut_used_gib { if hi == lo { + if k > 1 { + // The segment's first batch crosses the whole cut: find the + // culprit at per-block granularity before emitting anything. + eprintln!( + "[scan {chunk_id}/{n_chunks}] narrowing batch at block \ + {hi}: first claim crossed the cut" + ); + narrow_until = hi + k; + break (hi, prev_fft, prev_bytes); + } // A single block alone reaches the cut: atomically infeasible // at this budget — emitted alone with its measured cost. break (hi + 1, fft, bytes_gib); } break (hi, prev_fft, prev_bytes); } - hi += 1; + hi += k; prev_fft = fft; prev_bytes = bytes_gib; }; From 2705c4a2a441ae699b88eefd2be273aa72444db4 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Wed, 5 Aug 2026 15:02:54 +0000 Subject: [PATCH 09/20] aiur: drop in-execution RAM tracking; ix check --execute whole-env mode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Aiur execution carries no RAM instrumentation again: the thread-local record-byte budget, its charge in QueryMap::insert, the RecordBudgetExceeded variant, the interpreter polls, and the 3,538 codegen-emitted checks are all removed (kernels regenerated). The scanner's per-worker record share becomes a PLAN — worker-count arithmetic and logging, not an enforced cap: a worker's record is bounded at claim boundaries only, and the recourse for pathologically dense content is fewer workers. The narrow window remains solely for kernel-reject attribution. Scan partitions are unchanged (Init byte-identical pre/post). New: ix check --ixe env.ixe --execute — execute-only whole-env check through the codegen'd Aiur kernel, in parallel, with no partition, manifest, or prove concerns. Segments exist only to drop records (bytes-only cut at the planned share); the report is the check verdict: blocks checked, kernel rejects named, total measured FFT. --jobs bounds workers, --no-fail-fast inventories every reject. This is the Aiur-kernel counterpart of the Rust kernel's whole-env check, for wall-clock comparison and divergence hunting. Validated: Init 51,003/51,003 blocks in 68 s (peak 82.6 GiB); InitStd 87,847/87,847 in 116 s (145 GiB); Lean 152,596/152,596 in 210 s (164.5 GiB — exactly the 20-worker x 8.2 GiB plan line). ixvm suite green. --- Ix/Aiur/Semantics/BytecodeFfi.lean | 10 + Ix/Aiur/Stages/Codegen.lean | 15 +- Ix/Cli/CheckCmd.lean | 28 + crates/aiur/src/execute.rs | 52 - crates/aiur/src/querymap.rs | 1 - crates/ffi/src/aiur/scan.rs | 408 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 4657 +++++-------------- crates/ixvm-codegen/src/aiur_multi_stark.rs | 852 +--- 8 files changed, 1594 insertions(+), 4429 deletions(-) diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 0fdc6a32d..370be3379 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -229,6 +229,16 @@ opaque scanShardsWithEnv : @& Bytecode.Toplevel → @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → @& String → @& String → @& String → Except String Unit +/-- Execute-only whole-env check through the codegen'd Aiur kernel: no + partition, no manifest — the check verdict plus measured totals, + reported on stderr. Args: workers (0 = autoscale), fail-fast ("0" + records and skips kernel-rejected blocks; anything else aborts on + the first). -/ +@[extern "rs_aiur_execute_env_with_env"] +opaque executeEnvWithEnv : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → + Except String Unit + end Bytecode.Toplevel end Aiur diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 556e3ff6d..5fdf8fde2 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -419,9 +419,7 @@ private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt := s!" result.output[0]" ++ s!" } else \{" ++ s!" let __ptr = G::from_usize(__mq.len());" ++ - s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained));" ++ - s!" if record_budget_exceeded() \{ return Err(ExecError::RecordBudgetExceeded); }" ++ - s!" __ptr } }" + s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }" #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] /-- `Op::Load`: mirror execute.rs lines 328-345. Look up by pointer @@ -804,14 +802,8 @@ partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String) #[.ref (.index (.var "inp") (.lit "..")), .ref (.index (.var "__ret") (.lit "..")), gFromBool (.lit "!unconstrained")]) - -- The budget poll rides the memoization insert — the unit of record - -- growth — so a bounded execution aborts within one unique query of - -- its limit. - let budgetCheck : RustStmt := - .exprStmt (.lit - "if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }") -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>. - return #[outArr, insertCall, budgetCheck, + return #[outArr, insertCall, .returnStmt (.call (.var "Ok") #[.var "__ret"])] | .match valIdx cases dflt? => do -- Each arm body executes from the SAME value-stack snapshot as @@ -980,8 +972,7 @@ def optionalExecuteUses : Array (String × String) := #[ /-- Build the `use aiur::execute::{...};` block, including only items whose search token appears in `body`. -/ def emitConditionalImports (body : String) : String := Id.run do - let always : Array String := - #["ExecError", "IOBuffer", "QueryRecord", "record_budget_exceeded"] + let always : Array String := #["ExecError", "IOBuffer", "QueryRecord"] let mut items : Array String := always for (path, token) in optionalExecuteUses do if (body.splitOn token).length > 1 then diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 51c3e729c..8573348a3 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -674,6 +674,33 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do (p.flag? "stats-out").map (·.as! String) let ixePath : Option String := (p.flag? "ixe").map (·.as! String) + if p.hasFlag "execute" then + -- Execute-only whole-env check: the Aiur-kernel counterpart of the + -- Rust kernel's whole-env check — parallel execution of every + -- block's claim, no partition, no manifest, no prove concerns. + let some ixe := ixePath | do + p.printError "error: --execute requires --ixe" + return 1 + let toplevel ← match IxVM.ixVM with + | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 + | .ok t => pure t + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 + | .ok c => pure c + let funIdx ← match compiled.getFuncIdx `verify_claim with + | some i => pure i + | none => IO.eprintln "error: verify_claim missing"; return 1 + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h + let workers := (p.flag? "jobs").map (·.as! Nat) |>.getD 0 + let start ← IO.monoMsNow + match Aiur.Bytecode.Toplevel.executeEnvWithEnv compiled.bytecode funIdx + envHandle (toString workers) (if keepGoing then "0" else "1") with + | .error e => IO.eprintln s!"execute failed: {e}"; return 1 + | .ok () => + IO.println s!"execute: OK in {(← IO.monoMsNow) - start} ms" + return 0 let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList @@ -754,6 +781,7 @@ def checkCmd : Cli.Cmd := `[Cli| "fail-fast"; "Halt on the first failure (the default; flag accepted for explicitness)." "no-fail-fast"; "Continue past failures and report them at the end instead of halting on the first." "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." + "execute"; "Execute-only whole-env check (requires --ixe): run every block's check claim through the codegen'd Aiur kernel in parallel — no partition, no manifest, no proving. Reports blocks checked, kernel rejects (named), and total measured FFT cost. --jobs bounds the worker count (default: autoscale); combine with --no-fail-fast to inventory every reject." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)." "stats-out" : String; "Redirect the per-circuit statistics dump to this file (only used when exactly one constant is targeted)." "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." diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index b512e8e4a..5d6de2347 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -201,10 +201,6 @@ pub enum ExecError { msg: Option, }, MatchNoCase(u64), - /// The thread's record-growth budget was crossed (see - /// [`set_record_byte_budget`]): not a kernel verdict on the claim — the - /// driver that armed the budget re-runs or defers the work. - RecordBudgetExceeded, NoContinuation, StackNotEmpty, InvalidIOKey { @@ -248,9 +244,6 @@ impl std::fmt::Display for ExecError { None => write!(f, "assert_eq mismatch: {lhs} != {rhs}"), }, Self::MatchNoCase(v) => write!(f, "no match case for value {v}"), - Self::RecordBudgetExceeded => { - write!(f, "record byte budget exceeded") - }, Self::NoContinuation => write!(f, "yield without continuation"), Self::StackNotEmpty => { write!(f, "exec entries stack not empty at return") @@ -365,45 +358,6 @@ pub fn f64_from_usize(n: usize) -> f64 { f64::from(hi) * 4_294_967_296.0 + f64::from(lo) } -std::thread_local! { - /// Per-thread record-growth budget: `(bytes charged, byte limit)`. - /// Every [`QueryMap::insert`](crate::querymap::QueryMap::insert) charges - /// its entry's retained bytes; execution paths poll - /// [`record_budget_exceeded`] and abort with - /// [`ExecError::RecordBudgetExceeded`] once the limit is crossed. The - /// default limit is `usize::MAX`, so nothing changes unless a driver - /// (the shard scanner) opts a thread in around an execution it must be - /// able to bound — a single dense block can otherwise grow a record by - /// tens of GiB with no interior boundary to act on. - static RECORD_BYTE_BUDGET: std::cell::Cell<(usize, usize)> = - const { std::cell::Cell::new((0, usize::MAX)) }; -} - -/// Arm the calling thread's record-growth budget and zero its counter. -pub fn set_record_byte_budget(limit: usize) { - RECORD_BYTE_BUDGET.with(|c| c.set((0, limit))); -} - -/// Disarm the calling thread's record-growth budget. -pub fn clear_record_byte_budget() { - RECORD_BYTE_BUDGET.with(|c| c.set((0, usize::MAX))); -} - -/// Whether the calling thread has charged past its record-growth limit. -pub fn record_budget_exceeded() -> bool { - RECORD_BYTE_BUDGET.with(|c| { - let (used, limit) = c.get(); - used > limit - }) -} - -pub(crate) fn charge_record_bytes(bytes: usize) { - RECORD_BYTE_BUDGET.with(|c| { - let (used, limit) = c.get(); - c.set((used.saturating_add(bytes), limit)); - }); -} - /// Approximate resident bytes of a [`QueryRecord`]: retained key/output /// field elements (8 B each) plus ~13 B of per-entry index overhead /// (stored hash, table slot, multiplicity). The memory-circuit stores @@ -564,9 +518,6 @@ impl Function { &[ptr], G::from_bool(!unconstrained), ); - if record_budget_exceeded() { - return Err(ExecError::RecordBudgetExceeded); - } map.push(ptr); } }, @@ -889,9 +840,6 @@ impl Function { &output, G::from_bool(!unconstrained), ); - if record_budget_exceeded() { - return Err(ExecError::RecordBudgetExceeded); - } if let Some(CallerState { fun_idx: caller_idx, map: caller_map, diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 44d68ef0c..56f97306e 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -319,7 +319,6 @@ impl QueryMap { } else { debug_assert_eq!(output.len(), self.outs.stride); } - crate::execute::charge_record_bytes((key.len() + output.len()) * 8 + 13); let hash = hash_g_slice(key); let i = u32::try_from(self.mults.entries).expect("query map overflow"); self.keys.push(key); diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index 70bc5fc9b..f1668bebc 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -54,9 +54,8 @@ use rustc_hash::FxHashMap; use aiur::{ bytecode::Toplevel, execute::{ - ExecError, IOBuffer, QueryRecord, dump_query_stats, f64_from_usize, + IOBuffer, QueryRecord, dump_query_stats, f64_from_usize, query_stats_enabled, record_fft_cost, record_retained_bytes, - set_record_byte_budget, }, }; use ix_common::address::Address; @@ -76,13 +75,6 @@ use ixvm_codegen::aiur_ixvm_witness::{ /// Bytes per GiB. const GIB: f64 = 1_073_741_824.0; -/// GiB → bytes for budget caps, via the same lossless decimal -/// round-trip as [`cost_fft`] (no `as` cast): budgets are small positive -/// magnitudes, exact to the byte at every realistic scale. -fn gib_to_bytes(gib: f64) -> usize { - format!("{:.0}", (gib * GIB).max(0.0)).parse().unwrap_or(usize::MAX) -} - /// Fraction of detected system RAM the worker fleet may plan against. /// The fleet bound is arithmetic, not reactive: `workers × record cap` /// is chosen under this line at startup, and the per-worker cap is @@ -242,23 +234,21 @@ struct ScanCtx<'a> { /// boundary — a failure aborts the fleet in seconds, not after the /// in-flight ranges drain. abort: &'a std::sync::atomic::AtomicBool, - /// Per-worker segment-record byte cap, enforced INSIDE block execution - /// via the aiur thread-local budget: a worker's live record can never - /// exceed it, so the fleet's RAM is bounded by `workers × cap` by - /// construction — including through dense regions where a single block - /// grows its record by tens of GiB with no boundary to act on. A block - /// that crosses the cap alone is skipped and named, like a - /// kernel-rejected block: its record alone out-sizes a per-worker share - /// of this box, which at measured byte-per-fft ratios puts its prove - /// far beyond any single-shard budget. (`--workers 1` grants one worker - /// the whole allowance when such a block must be measured anyway.) - seg_byte_budget: usize, /// Blocks per measurement claim. Batching divides the claim layer's /// per-claim overhead (assumption-tree hashing, unshared `env_walk` /// frames) by K and shrinks frontiers (intra-batch edges stop being /// frontier members), keeping the running readout tight enough to /// serve as the shard cost without a blanket re-price. batch_blocks: usize, + /// Execute-only mode: the cut charges RECORD BYTES alone against + /// `cut_used_gib` (a per-worker share of box RAM) — segments exist only + /// to drop records and keep the fleet resident — and no partition + /// semantics attach to the boundaries. RAM is bounded at claim + /// granularity only: a single claim's growth is uninstrumented by + /// design (Aiur execution carries no RAM tracking), so + /// pathologically dense content is bounded by worker count, not by + /// abort. + exec_only: bool, } /// Default blocks per measurement claim; `IX_SCAN_BATCH_BLOCKS` @@ -270,25 +260,27 @@ struct ScanCtx<'a> { /// manifest cost. const SCAN_BATCH_BLOCKS: usize = 128; -/// Smallest useful per-worker record cap, GiB. Typical segments at any +/// Smallest useful per-worker record share, GiB. Typical segments at any /// realistic cut carry 3–8 GiB of record (measured 4–10% of the combined -/// cut across envs), so a cap at this floor still lets normal segments +/// cut across envs), so a share at this floor still lets normal segments /// reach their cut untouched. -const MIN_WORKER_CAP_GIB: f64 = 8.0; +const MIN_WORKER_SHARE_GIB: f64 = 8.0; -/// Joint worker-count / record-cap arithmetic: the fleet plans against +/// Joint worker-count / record-share arithmetic: the fleet plans against /// `RAM_CEILING_FRAC × box − 10` (decode cache, witness maps, claim -/// trees), workers split it evenly, and each worker's share IS its -/// enforced record cap — the fleet bound is `workers × cap` by -/// construction, no reactive control. Fewer workers means a bigger cap -/// (`--workers 1` grants the whole allowance). Returns `(workers, -/// cap_gib)`; `IX_SCAN_SEG_BYTE_BUDGET_GIB` overrides the cap for tests. +/// trees), split evenly across workers. The share is a PLAN, not an +/// enforced cap — Aiur execution carries no RAM instrumentation, so a +/// worker's record is bounded only at claim boundaries (segments drop +/// records); pathologically dense single claims can exceed the share, +/// and the recourse is fewer workers (`--workers 1` plans the whole +/// allowance). `IX_SCAN_WORKER_SHARE_GIB` overrides for tests. Returns +/// `(workers, share_gib)`. fn fleet_plan(workers: usize, cut_used_gib: f64) -> (usize, f64) { let cores = std::thread::available_parallelism().map_or(4, usize::from); let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - let usable = ram.mul_add(RAM_CEILING_FRAC, -10.0).max(MIN_WORKER_CAP_GIB); + let usable = ram.mul_add(RAM_CEILING_FRAC, -10.0).max(MIN_WORKER_SHARE_GIB); let workers = if workers == 0 { - let by_ram = format!("{:.0}", (usable / MIN_WORKER_CAP_GIB).floor()) + let by_ram = format!("{:.0}", (usable / MIN_WORKER_SHARE_GIB).floor()) .parse::() .unwrap_or(1) .max(1); @@ -296,83 +288,50 @@ fn fleet_plan(workers: usize, cut_used_gib: f64) -> (usize, f64) { } else { workers }; - let cap_gib = std::env::var("IX_SCAN_SEG_BYTE_BUDGET_GIB") + let share_gib = std::env::var("IX_SCAN_WORKER_SHARE_GIB") .ok() .and_then(|v| v.parse::().ok()) .unwrap_or_else(|| (usable / f64_from_usize(workers)).min(cut_used_gib)); - (workers, cap_gib) + (workers, share_gib) } -/// Scan-and-cut over the whole env: returns the manifest report, writing -/// the manifest and its costs sidecar to `out_path`. -#[allow(clippy::too_many_arguments)] -pub fn scan_shards( - toplevel: &Toplevel, - fun_idx: usize, - env: &Arc, - budget_gib: f64, - eps: f64, - workers: usize, - fail_fast: bool, - out_path: &str, -) -> Result { - let cap_gib = budget_gib * AIUR_RAM_USABLE_FRAC; - if cap_gib <= AIUR_RAM_BASE_GIB { - return Err(format!( - "budget {budget_gib} GiB leaves no headroom over the {AIUR_RAM_BASE_GIB} GiB base" - )); - } - // The ε-discounted headroom above the prove base, in GiB. The cut - // charges BOTH resource terms against it: slope·fft (trace/FFT RAM) - // plus the measured record bytes the prove's execute replays into. - let cut_used_gib = (cap_gib - AIUR_RAM_BASE_GIB) * (1.0 - eps); - // FFT-equivalent of the headroom, for the worker autoscale estimate. - let cut_fft = cut_used_gib / AIUR_RAM_GIB_PER_BFFT * 1e9; - - let (blocks, adj) = schedule_blocks(env); - if blocks.is_empty() { - return Err("empty environment".to_string()); - } - let env_bytes: u64 = blocks.iter().map(|b| b.size).sum(); - let (workers, seg_budget_gib) = fleet_plan(workers, cut_used_gib); - let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") - .ok() - .and_then(|v| v.parse::().ok()) - .filter(|&k| k >= 1) - .unwrap_or(SCAN_BATCH_BLOCKS); - let n_chunks = (workers * 2).min(blocks.len()); - eprintln!( - "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut {:.1} \ - GiB combined (≈{:.1} BFFT fft-only), {seg_budget_gib:.1} GiB record \ - cap per worker, {batch_blocks} blocks per claim", - blocks.len(), - cut_used_gib, - cut_fft / 1e9 - ); - let mut order = static_order(&blocks, &adj, n_chunks.max(16)); - // Debug knob: truncate the schedule to its first N blocks — a - // full-pipeline reproducer over a slice of a huge env, without - // extracting one. The manifest then does NOT cover the env. +/// The min-cut schedule order, truncated by the `IX_SCAN_LIMIT_BLOCKS` +/// debug knob (a full-pipeline reproducer over a slice of a huge env, +/// without extracting one; the result then does NOT cover the env). +fn ordered_schedule( + blocks: &[SchedBlock], + adj: &[Vec], + n_chunks: usize, +) -> Vec { + let mut order = static_order(blocks, adj, n_chunks.max(16)); if let Some(limit) = std::env::var("IX_SCAN_LIMIT_BLOCKS") .ok() .and_then(|v| v.parse::().ok()) && limit < order.len() { eprintln!( - "[scan] IX_SCAN_LIMIT_BLOCKS={limit}: scanning a schedule PREFIX — \ - the manifest will not cover the env" + "[scan] IX_SCAN_LIMIT_BLOCKS={limit}: executing a schedule PREFIX — \ + the result will not cover the env" ); order.truncate(limit); } + order +} - // Equal-byte contiguous chunks over the order; edges are forced shard - // boundaries (the parallelism unit); the merge pass below repairs the - // resulting fragmentation, so chunk count is a pure parallelism knob. +/// Equal-byte contiguous chunks over the order; edges are forced segment +/// boundaries (the parallelism unit); the scan's merge pass repairs the +/// resulting fragmentation, so chunk count is a pure parallelism knob. +fn make_chunks( + order: &[u32], + blocks: &[SchedBlock], + env_bytes: u64, + n_chunks: usize, +) -> Vec> { let per_chunk = (env_bytes / n_chunks as u64).max(1); let mut chunks: Vec> = Vec::new(); let mut cur: Vec = Vec::new(); let mut acc = 0u64; - for &b in &order { + for &b in order { cur.push(b); acc += blocks[b as usize].size; if acc >= per_chunk && chunks.len() + 1 < n_chunks { @@ -387,41 +346,27 @@ pub fn scan_shards( // constant into the shared env's lazy cache, so this RSS is (cache + // static structures) — the floor the worker footprints sit on. eprintln!("[scan] post-schedule baseline rss {:.0}G", process_rss_gib()); + chunks +} - // Work-stealing ranges: workers pull `(origin chunk, seq, hint, blocks)` - // ranges off a shared deque; a range yields at most `RANGE_SEGMENTS` - // segments, then re-queues its remainder for any idle worker. Dense - // regions — where one equal-byte chunk can hold hours of sequential - // measurement — therefore self-parallelize; the extra forced boundaries - // this creates are repaired by the merge + re-measure pass like any - // others. The split policy is count-based, not time- or RAM-based, so - // the resulting partition does not depend on scheduling (governor sheds - // under RAM pressure excepted — there, safety wins). Segments are - // tagged `(origin, seq)` and sorted at the end, so the final order is - // the schedule order. - let failed: Mutex> = Mutex::new(Vec::new()); - let abort = std::sync::atomic::AtomicBool::new(false); - let ctx = ScanCtx { - toplevel, - fun_idx, - env, - blocks: &blocks, - cut_used_gib, - n_chunks: chunks.len(), - fail_fast, - failed: &failed, - abort: &abort, - seg_byte_budget: gib_to_bytes(seg_budget_gib), - batch_blocks, - }; +/// Work-stealing worker pool over the chunks: workers pull `(origin +/// chunk, seq, blocks)` ranges off a shared deque; a range yields at +/// most [`RANGE_SEGMENTS`] segments, then re-queues its remainder for +/// any idle worker, so dense regions self-parallelize. The split policy +/// is count-based, not time- or RAM-based, so the resulting segments do +/// not depend on scheduling; they are tagged `(origin, seq)` and sorted +/// at the end, so the returned order is the schedule order. +fn run_pool( + ctx: &ScanCtx<'_>, + chunks: Vec>, + workers: usize, +) -> Result, String> { type Range = (u32, u32, Vec); let queue: Mutex> = Mutex::new( chunks - .iter() + .into_iter() .enumerate() - .map(|(i, c)| { - (u32::try_from(i).expect("chunk count fits u32"), 0u32, c.clone()) - }) + .map(|(i, c)| (u32::try_from(i).expect("chunk count fits u32"), 0u32, c)) .collect(), ); let in_flight = AtomicUsize::new(0); @@ -457,7 +402,7 @@ pub fn scan_shards( std::thread::sleep(std::time::Duration::from_millis(50)); continue; }; - match scan_range(&ctx, &range, origin) { + match scan_range(ctx, &range, origin) { Ok((segs, rest)) => { done.lock().unwrap().push(((origin, seq), segs)); // Remainder goes back BEFORE the in-flight decrement, so @@ -488,6 +433,147 @@ pub fn scan_shards( for (_, mut segs) in tagged { segments.append(&mut segs); } + Ok(segments) +} + +/// Execute-only mode: run the whole env's check schedule through the +/// codegen'd kernel in parallel — no partition, no manifest, no prove +/// concerns. Segments exist only to drop records (cut when a worker's +/// record bytes reach its planned share of box RAM), and the report is +/// the check verdict: blocks checked, kernel rejects named, total +/// measured FFT cost. This is the Aiur-kernel counterpart of the Rust +/// kernel's whole-env check, for wall-clock comparison and for finding +/// divergences (constants one kernel accepts and the other rejects). +pub fn execute_env( + toplevel: &Toplevel, + fun_idx: usize, + env: &Arc, + workers: usize, + fail_fast: bool, +) -> Result { + let (blocks, adj) = schedule_blocks(env); + if blocks.is_empty() { + return Err("empty environment".to_string()); + } + let env_bytes: u64 = blocks.iter().map(|b| b.size).sum(); + let (workers, share_gib) = fleet_plan(workers, f64::INFINITY); + let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") + .ok() + .and_then(|v| v.parse::().ok()) + .filter(|&k| k >= 1) + .unwrap_or(SCAN_BATCH_BLOCKS); + let n_chunks = (workers * 2).min(blocks.len()); + eprintln!( + "[exec] {} blocks, {workers} workers over {n_chunks} chunks, \ + {share_gib:.1} GiB record share per worker (planned), {batch_blocks} \ + blocks per claim", + blocks.len() + ); + let order = ordered_schedule(&blocks, &adj, n_chunks); + let covered = order.len(); + let chunks = make_chunks(&order, &blocks, env_bytes, n_chunks); + let failed: Mutex> = Mutex::new(Vec::new()); + let abort = std::sync::atomic::AtomicBool::new(false); + let ctx = ScanCtx { + toplevel, + fun_idx, + env, + blocks: &blocks, + cut_used_gib: share_gib, + n_chunks: chunks.len(), + fail_fast, + failed: &failed, + abort: &abort, + batch_blocks, + exec_only: true, + }; + let segments = run_pool(&ctx, chunks, workers)?; + let total_fft: f64 = segments.iter().map(|s| s.fft).sum(); + let checked: usize = segments.iter().map(|s| s.blocks.len()).sum(); + let failed = failed.into_inner().unwrap(); + let mut report = format!( + "execute: {checked}/{covered} blocks checked in {} segment(s), total \ + measured {:.1} BFFT", + segments.len(), + total_fft / 1e9, + ); + if !failed.is_empty() { + report.push_str(&format!( + "\n [{} kernel-rejected block(s) SKIPPED:]", + failed.len() + )); + for (a, e) in &failed { + report.push_str(&format!("\n {} — {e}", a.hex())); + } + } + Ok(report) +} + +/// Scan-and-cut over the whole env: returns the manifest report, writing +/// the manifest and its costs sidecar to `out_path`. +#[allow(clippy::too_many_arguments)] +pub fn scan_shards( + toplevel: &Toplevel, + fun_idx: usize, + env: &Arc, + budget_gib: f64, + eps: f64, + workers: usize, + fail_fast: bool, + out_path: &str, +) -> Result { + let cap_gib = budget_gib * AIUR_RAM_USABLE_FRAC; + if cap_gib <= AIUR_RAM_BASE_GIB { + return Err(format!( + "budget {budget_gib} GiB leaves no headroom over the {AIUR_RAM_BASE_GIB} GiB base" + )); + } + // The ε-discounted headroom above the prove base, in GiB. The cut + // charges BOTH resource terms against it: slope·fft (trace/FFT RAM) + // plus the measured record bytes the prove's execute replays into. + let cut_used_gib = (cap_gib - AIUR_RAM_BASE_GIB) * (1.0 - eps); + // FFT-equivalent of the headroom, for the worker autoscale estimate. + let cut_fft = cut_used_gib / AIUR_RAM_GIB_PER_BFFT * 1e9; + + let (blocks, adj) = schedule_blocks(env); + if blocks.is_empty() { + return Err("empty environment".to_string()); + } + let env_bytes: u64 = blocks.iter().map(|b| b.size).sum(); + let (workers, seg_budget_gib) = fleet_plan(workers, cut_used_gib); + let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") + .ok() + .and_then(|v| v.parse::().ok()) + .filter(|&k| k >= 1) + .unwrap_or(SCAN_BATCH_BLOCKS); + let n_chunks = (workers * 2).min(blocks.len()); + eprintln!( + "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut {:.1} \ + GiB combined (≈{:.1} BFFT fft-only), {seg_budget_gib:.1} GiB record \ + share per worker (planned), {batch_blocks} blocks per claim", + blocks.len(), + cut_used_gib, + cut_fft / 1e9 + ); + let order = ordered_schedule(&blocks, &adj, n_chunks); + let chunks = make_chunks(&order, &blocks, env_bytes, n_chunks); + let chunk_count = chunks.len(); + let failed: Mutex> = Mutex::new(Vec::new()); + let abort = std::sync::atomic::AtomicBool::new(false); + let ctx = ScanCtx { + toplevel, + fun_idx, + env, + blocks: &blocks, + cut_used_gib, + n_chunks: chunk_count, + fail_fast, + failed: &failed, + abort: &abort, + batch_blocks, + exec_only: false, + }; + let segments = run_pool(&ctx, chunks, workers)?; // Merge + re-measure to a fixpoint. Merging by FFT sum is always safe // (the union's real cost is ≤ the sum: shared deps derive once) but the @@ -674,7 +760,7 @@ pub fn scan_shards( predicted prove RSS {max_ram:.1} GiB (fft line + measured record \ bytes){note}", blocks.len(), - chunks.len(), + chunk_count, cut_used_gib, eps * 100.0, )) @@ -749,10 +835,6 @@ fn scan_range( let mut narrow_until = 0usize; while lo < chunk.len() && segments.len() < RANGE_SEGMENTS { let mut record = QueryRecord::new(ctx.toplevel); - // Arm the per-worker record cap for this fresh record. Worker threads - // run nothing but scan ranges, and arming resets the charge counter, - // so per-segment arming with no disarm is sufficient. - set_record_byte_budget(ctx.seg_byte_budget); let mut io = IOBuffer::with_backing(EnvFaultSource::new(ctx.env.clone())); let mut prev_fft = 0.0f64; let mut prev_bytes = 0.0f64; @@ -774,12 +856,9 @@ fn scan_range( .iter() .map(|&b| ctx.blocks[b as usize].addr.clone()) .collect(); - // `Err(None)` = the record cap tripped mid-claim (not a kernel - // verdict); `Err(Some(e))` = the kernel rejected a block. - let out: Result<(), Option> = - seed_shard_check_env_claim(ctx.env, &addrs, &mut io) - .map_err(Some) - .and_then(|(_claim, input)| { + let out: Result<(), String> = + seed_shard_check_env_claim(ctx.env, &addrs, &mut io).and_then( + |(_claim, input)| { execute_ixvm_with_record( ctx.toplevel, ctx.fun_idx, @@ -788,40 +867,22 @@ fn scan_range( &mut record, ) .map(|_| ()) - .map_err(|e| match e { - ExecError::RecordBudgetExceeded => None, - other => Some(other.to_string()), - }) - }); - // A cap trip on a segment that already holds claims is an early - // cut, not a failure: cut at the previous checkpoint; the crossing - // batch restarts the next segment with a fresh record and full - // cap, and only narrows if it then trips with nothing banked. - if matches!(out, Err(None)) && hi > lo { - break (hi, prev_fft, prev_bytes); - } - if let Err(err) = out { + .map_err(|e| e.to_string()) + }, + ); + if let Err(e) = out { if k > 1 { // Per-block attribution needed: end the segment at the last // clean checkpoint (dropping the polluted record) and rescan // this batch one block per claim. eprintln!( "[scan {chunk_id}/{n_chunks}] narrowing batch at block \ - {hi}: {}", - err.as_deref().unwrap_or("record cap crossed") + {hi}: {e}" ); narrow_until = hi + k; break (hi, prev_fft, prev_bytes); } let addr = &addrs[0]; - let e = err.unwrap_or_else(|| { - format!( - "record bytes crossed the {:.1} GiB per-worker cap alone — \ - resource-infeasible at this box share (--workers 1 grants \ - the whole allowance)", - f64_from_usize(ctx.seg_byte_budget) / GIB - ) - }); if ctx.fail_fast { return Err(format!( "CheckEnv of block {} failed during scan: {e} \ @@ -842,7 +903,14 @@ fn scan_range( } let fft = record_fft_cost(ctx.toplevel, &record); let bytes_gib = f64_from_usize(record_retained_bytes(&record)) / GIB; - let used = AIUR_RAM_GIB_PER_BFFT * fft / 1e9 + bytes_gib; + // Execute-only segments exist to bound the live record, so only + // bytes count against the (per-worker share) cut; the scan's cut + // charges both prove resources against the budget headroom. + let used = if ctx.exec_only { + bytes_gib + } else { + AIUR_RAM_GIB_PER_BFFT * fft / 1e9 + bytes_gib + }; if used >= ctx.cut_used_gib { if hi == lo { if k > 1 { @@ -969,3 +1037,33 @@ extern "C" fn rs_aiur_scan_shards_with_env( Err(e) => LeanExcept::error_string(&format!("rs_aiur_scan_shards: {e}")), } } + +/// `Bytecode.Toplevel.executeEnvWithEnv`: execute-only whole-env check +/// through the codegen'd Aiur kernel — no partition, no manifest (see +/// [`execute_env`]). Numeric params are decimal strings (ABI-simple): +/// `workers` (`0` autoscales), `fail_fast` (`0` records and skips +/// kernel-rejected blocks instead of aborting). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_execute_env_with_env( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + env_handle: LeanExternal< + ixvm_codegen::env_handle::EnvHandle, + LeanBorrowed<'_>, + >, + workers: LeanString>, + fail_fast: LeanString>, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = crate::aiur::lean_unbox_nat_as_usize(fun_idx.inner()); + let workers = workers.to_string().parse::().unwrap_or(0); + let fail_fast = fail_fast.to_string() != "0"; + match execute_env(&toplevel, fun_idx, &env_handle.get().env, workers, fail_fast) + { + Ok(report) => { + eprintln!("[rs_exec]\n{report}"); + LeanExcept::ok(LeanOwned::box_usize(0)) + }, + Err(e) => LeanExcept::error_string(&format!("rs_aiur_execute_env: {e}")), + } +} diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index 18eb72588..7c431102a 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -14,7 +14,7 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; -use aiur::execute::{ ExecError, IOBuffer, QueryRecord, record_budget_exceeded, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_and_value, bytes2_or_value, bytes2_less_than_value, bytes2_add_value, bytes2_sub_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; +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_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; @@ -268,14 +268,12 @@ fn aiur_fn_0( let __v_227: G = G::from_u64(1); let __ret: [G; OUT_0] = [__v_227]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_227: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_227]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -284,7 +282,6 @@ fn aiur_fn_0( let __v_214: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_214]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -293,7 +290,6 @@ fn aiur_fn_0( let __v_177: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_177]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -302,7 +298,6 @@ fn aiur_fn_0( let __v_140: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_140]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -311,7 +306,6 @@ fn aiur_fn_0( let __v_103: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_103]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -403,14 +397,12 @@ fn aiur_fn_1( let __v_67: G = __r_arr[0]; let __ret: [G; OUT_1] = [__v_67]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_67]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -434,10 +426,9 @@ fn aiur_fn_2( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_2] = [__v_5]; record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -450,10 +441,9 @@ fn aiur_fn_2( let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_2] = [__v_10]; record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -495,14 +485,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -513,14 +501,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -535,14 +521,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -553,14 +537,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -579,14 +561,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -597,14 +577,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -619,14 +597,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -637,14 +613,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -667,14 +641,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -685,14 +657,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -707,14 +677,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -725,14 +693,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -751,14 +717,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -769,14 +733,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -791,14 +753,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -809,14 +769,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -843,14 +801,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(3); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -861,14 +817,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -883,14 +837,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -901,14 +853,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -927,14 +877,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -945,14 +893,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -967,14 +913,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -985,14 +929,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1015,14 +957,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1033,14 +973,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1055,14 +993,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1073,14 +1009,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1099,14 +1033,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1117,14 +1049,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1139,14 +1069,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1157,14 +1085,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1195,14 +1121,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1213,14 +1137,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1235,14 +1157,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1253,14 +1173,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1279,14 +1197,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1297,14 +1213,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1319,14 +1233,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1337,14 +1249,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1367,14 +1277,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1385,14 +1293,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1407,14 +1313,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1425,14 +1329,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1451,14 +1353,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1469,14 +1369,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1491,14 +1389,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1509,14 +1405,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1543,14 +1437,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(3); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1561,14 +1453,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1583,14 +1473,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1601,14 +1489,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1627,14 +1513,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1645,14 +1529,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1667,14 +1549,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1685,14 +1565,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1715,14 +1593,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1733,14 +1609,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1755,14 +1629,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1773,14 +1645,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1799,14 +1669,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1817,14 +1685,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1839,14 +1705,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1857,14 +1721,12 @@ fn aiur_fn_3( let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1920,14 +1782,12 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1936,7 +1796,6 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1945,7 +1804,6 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1954,7 +1812,6 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1963,7 +1820,6 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1972,7 +1828,6 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1981,7 +1836,6 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1990,7 +1844,6 @@ fn aiur_fn_4( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2040,7 +1893,6 @@ fn aiur_fn_5( let __v_23: G = __b2_add.1; let __ret: [G; OUT_5] = [__v_8, __v_12, __v_17, __v_22]; record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2069,7 +1921,6 @@ fn aiur_fn_6( let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2090,7 +1941,6 @@ fn aiur_fn_7( let __v_3: G = inp[3]; let __ret: [G; OUT_7] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2111,7 +1961,6 @@ fn aiur_fn_8( let __v_3: G = inp[3]; let __ret: [G; OUT_8] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2142,7 +1991,6 @@ fn aiur_fn_9( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_9] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2173,7 +2021,6 @@ fn aiur_fn_10( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_10] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2231,14 +2078,12 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(1); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2247,7 +2092,6 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2256,7 +2100,6 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2265,7 +2108,6 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2274,7 +2116,6 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2283,7 +2124,6 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2292,7 +2132,6 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2301,7 +2140,6 @@ fn aiur_fn_11( let __v_24: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_24]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2388,7 +2226,6 @@ fn aiur_fn_12( let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_12] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2437,7 +2274,6 @@ fn aiur_fn_13( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2452,7 +2288,6 @@ fn aiur_fn_13( let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2468,7 +2303,6 @@ fn aiur_fn_13( let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2483,7 +2317,6 @@ fn aiur_fn_13( let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2497,7 +2330,6 @@ fn aiur_fn_13( let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2510,7 +2342,6 @@ fn aiur_fn_13( let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2522,7 +2353,6 @@ fn aiur_fn_13( let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_13] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2533,7 +2363,6 @@ fn aiur_fn_13( let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2543,7 +2372,6 @@ fn aiur_fn_13( let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2594,7 +2422,6 @@ fn aiur_fn_14( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2609,7 +2436,6 @@ fn aiur_fn_14( let __v_16: G = (__v_7 - __v_15); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2625,7 +2451,6 @@ fn aiur_fn_14( let __v_15: G = (__v_6 - __v_14); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2640,7 +2465,6 @@ fn aiur_fn_14( let __v_14: G = (__v_5 - __v_13); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2654,7 +2478,6 @@ fn aiur_fn_14( let __v_13: G = (__v_4 - __v_12); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2667,7 +2490,6 @@ fn aiur_fn_14( let __v_12: G = (__v_3 - __v_11); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2679,7 +2501,6 @@ fn aiur_fn_14( let __v_11: G = (__v_2 - __v_10); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2690,7 +2511,6 @@ fn aiur_fn_14( let __v_10: G = (__v_1 - __v_9); let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2700,7 +2520,6 @@ fn aiur_fn_14( let __v_9: G = (__v_0 - __v_8); let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2749,7 +2568,6 @@ fn aiur_fn_15( let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_15] = [__v_26]; record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2799,7 +2617,7 @@ fn aiur_fn_16( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); @@ -2810,11 +2628,11 @@ fn aiur_fn_16( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -2887,7 +2705,6 @@ fn aiur_fn_16( let __v_117: G = __r_arr[31]; let __ret: [G; OUT_16] = [__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]; record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -3066,7 +2883,6 @@ fn aiur_fn_17( } let __ret: [G; OUT_17] = []; record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -3115,10 +2931,9 @@ fn aiur_fn_18( let __v_30: G = __r_arr[29]; let __v_31: G = __r_arr[30]; let __v_32: G = __r_arr[31]; - let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_18] = [__v_33]; record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -3207,7 +3022,6 @@ fn aiur_fn_19( let __v_69: G = G::from_u64(1); let __ret: [G; OUT_19] = [__v_67, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -3320,7 +3134,6 @@ fn aiur_fn_19( let __v_169: G = G::from_u64(1); let __ret: [G; OUT_19] = [__v_169, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -3407,10 +3220,9 @@ fn aiur_fn_19( let __v_246: G = G::from_u64(0); let __v_247: G = G::from_u64(0); let __v_248: G = G::from_u64(0); - let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_19] = [__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_248, __v_249, __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, __v_242, __v_243, __v_244, __v_245]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3459,10 +3271,9 @@ fn aiur_fn_19( let __v_244: G = G::from_u64(0); let __v_245: G = G::from_u64(0); let __v_246: G = G::from_u64(0); - let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_19] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __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, __v_242, __v_243]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -3564,7 +3375,6 @@ fn aiur_fn_20( 1u64 => { let __ret: [G; OUT_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_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3709,12 +3519,11 @@ fn aiur_fn_20( let __v_201: G = __r_arr[31]; let __ret: [G; OUT_20] = [__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, __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]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_170: G = G::from_u64(0); - let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_170, __v_171, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; @@ -3750,7 +3559,6 @@ fn aiur_fn_20( let __v_203: G = __r_arr[31]; let __ret: [G; OUT_20] = [__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, __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]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3794,19 +3602,17 @@ fn aiur_fn_21( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_21] = [__v_10]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_21] = [__v_12]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3818,7 +3624,6 @@ fn aiur_fn_21( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_21] = [__v_16]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4227,7 +4032,6 @@ fn aiur_fn_22( 0u64 => { let __ret: [G; OUT_22] = [__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[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -4568,20 +4372,18 @@ fn aiur_fn_23( 0u64 => { let __ret: [G; OUT_23] = [__v_0]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_23] = [__v_7]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4779,16 +4581,14 @@ fn aiur_fn_24( let __v_154: G = __r_arr[29]; let __v_155: G = __r_arr[30]; let __v_156: G = __r_arr[31]; - let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_24] = [__v_157]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4796,7 +4596,6 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4804,7 +4603,6 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4812,7 +4610,6 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4820,7 +4617,6 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4828,7 +4624,6 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4836,7 +4631,6 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4844,7 +4638,6 @@ fn aiur_fn_24( _ => { let __ret: [G; OUT_24] = [__v_5]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4884,10 +4677,9 @@ fn aiur_fn_24( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_24] = [__v_42]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -5055,10 +4847,9 @@ fn aiur_fn_24( let __v_161: G = __r_arr[29]; let __v_162: G = __r_arr[30]; let __v_163: G = __r_arr[31]; - let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_24] = [__v_164]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -5276,10 +5067,10 @@ fn aiur_fn_25( let __v_189: G = __r_arr[29]; let __v_190: G = __r_arr[30]; let __v_191: G = __r_arr[31]; - let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_193: G = G::from_u64(1); let __v_194: G = G::from_u64(1); - let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_196: G = G::from_u64(0); let __v_197: G = G::from_u64(0); let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; @@ -5300,13 +5091,12 @@ fn aiur_fn_25( let __v_211: G = __r_arr[5]; let __v_212: G = __r_arr[6]; let __v_213: G = __r_arr[7]; - let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_216: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_216]; record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -5412,16 +5202,15 @@ fn aiur_fn_25( let __v_165: G = __r_arr[31]; let __v_166: G = G::from_u64(1); let __v_167: G = G::from_u64(1); - let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_169: G = G::from_u64(0); let __v_170: G = G::from_u64(1); let __v_171: G = (__v_2 + __v_170); - let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_173: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_173]; record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -5638,7 +5427,6 @@ fn aiur_fn_26( let __v_151: G = (__v_148 + __v_146); let __ret: [G; OUT_26] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120]; record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -5919,7 +5707,6 @@ fn aiur_fn_27( let __v_255: G = __r_arr[15]; let __ret: [G; OUT_27] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __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[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6999,7 +6786,6 @@ fn aiur_fn_28( let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) }; let __ret: [G; OUT_28] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055]; record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7040,7 +6826,6 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -7049,7 +6834,6 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -7071,7 +6855,6 @@ fn aiur_fn_29( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_30]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -7093,7 +6876,6 @@ fn aiur_fn_29( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_30]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -7125,7 +6907,6 @@ fn aiur_fn_29( let __v_40: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_40]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -7134,7 +6915,6 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -7143,7 +6923,6 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -7163,7 +6942,6 @@ fn aiur_fn_29( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_29]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -7183,7 +6961,6 @@ fn aiur_fn_29( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_29]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -7203,7 +6980,6 @@ fn aiur_fn_29( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_29]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -7275,7 +7051,6 @@ fn aiur_fn_29( let __v_77: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_77]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { @@ -7284,7 +7059,6 @@ fn aiur_fn_29( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_20]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7318,7 +7092,6 @@ fn aiur_fn_30( 0u64 => { let __ret: [G; OUT_30] = [__v_9]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7328,10 +7101,9 @@ fn aiur_fn_30( let __v_13: G = (__v_8 - __v_12); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_30] = [__v_15]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7366,10 +7138,9 @@ fn aiur_fn_31( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_31] = [__v_13]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7380,10 +7151,9 @@ fn aiur_fn_31( let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_31] = [__v_18]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7396,10 +7166,9 @@ fn aiur_fn_31( let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_31] = [__v_18]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7438,10 +7207,9 @@ fn aiur_fn_32( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_32] = [__v_17]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7455,10 +7223,9 @@ fn aiur_fn_32( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_32] = [__v_22]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7474,10 +7241,9 @@ fn aiur_fn_32( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_32] = [__v_22]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7516,10 +7282,9 @@ fn aiur_fn_33( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_33] = [__v_17]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7533,10 +7298,9 @@ fn aiur_fn_33( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_33] = [__v_22]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7552,10 +7316,9 @@ fn aiur_fn_33( let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_33] = [__v_22]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7589,7 +7352,6 @@ fn aiur_fn_34( 1u64 => { let __ret: [G; OUT_34] = [__v_1]; record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -7599,7 +7361,6 @@ fn aiur_fn_34( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_13]; record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7678,7 +7439,6 @@ fn aiur_fn_35( let __v_51: G = __r_arr[7]; let __ret: [G; OUT_35] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7692,7 +7452,6 @@ fn aiur_fn_35( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7768,7 +7527,6 @@ fn aiur_fn_36( let __v_51: G = __r_arr[7]; let __ret: [G; OUT_36] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7782,7 +7540,6 @@ fn aiur_fn_36( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7858,7 +7615,6 @@ fn aiur_fn_37( let __v_51: G = __r_arr[7]; let __ret: [G; OUT_37] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7872,7 +7628,6 @@ fn aiur_fn_37( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_37] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7954,7 +7709,6 @@ fn aiur_fn_38( let __v_56: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_56]; record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7962,7 +7716,6 @@ fn aiur_fn_38( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_19]; record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8044,7 +7797,6 @@ fn aiur_fn_39( let __v_56: G = __r_arr[0]; let __ret: [G; OUT_39] = [__v_56]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8052,7 +7804,6 @@ fn aiur_fn_39( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_39] = [__v_19]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8134,7 +7885,6 @@ fn aiur_fn_40( let __v_56: G = __r_arr[0]; let __ret: [G; OUT_40] = [__v_56]; record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8142,7 +7892,6 @@ fn aiur_fn_40( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_40] = [__v_19]; record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8195,72 +7944,71 @@ fn aiur_fn_41( let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_50: G = G::from_u64(0); - let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(0); - let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_56: G = G::from_u64(0); - let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_60: G = G::from_u64(0); - let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_62: G = G::from_u64(0); - let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_68: G = G::from_u64(0); - let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_70: G = G::from_u64(0); - let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_72: G = G::from_u64(0); - let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(0); - let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_76: G = G::from_u64(0); - let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_78: G = G::from_u64(0); - let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_80: G = G::from_u64(0); - let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_82: G = G::from_u64(0); - let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_84: G = G::from_u64(0); - let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_86: G = G::from_u64(0); - let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_88: G = G::from_u64(0); - let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_90: G = G::from_u64(0); - let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_92: G = G::from_u64(0); - let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_94: G = G::from_u64(0); - let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_96: G = G::from_u64(0); - let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_41] = [__v_97]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8284,21 +8032,18 @@ fn aiur_fn_42( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8312,21 +8057,18 @@ fn aiur_fn_42( let __v_2: G = G::from_u64(4); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8340,21 +8082,18 @@ fn aiur_fn_42( let __v_2: G = G::from_u64(8); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); let __ret: [G; OUT_42] = [__v_2]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8420,7 +8159,6 @@ fn aiur_fn_43( let __v_33: G = __r_arr[7]; let __ret: [G; OUT_43] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8434,7 +8172,6 @@ fn aiur_fn_43( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_43] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8484,13 +8221,11 @@ fn aiur_fn_44( let __v_26: G = __r_arr[8]; let __ret: [G; OUT_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8521,10 +8256,9 @@ fn aiur_fn_45( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_45] = [__v_12]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -8554,7 +8288,6 @@ fn aiur_fn_45( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_29]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -8595,7 +8328,6 @@ fn aiur_fn_45( let __v_39: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_39]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -8636,7 +8368,6 @@ fn aiur_fn_45( let __v_39: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_39]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -8645,7 +8376,6 @@ fn aiur_fn_45( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_11]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8675,7 +8405,6 @@ fn aiur_fn_46( 1u64 => { let __ret: [G; OUT_46] = [__v_1]; record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8704,7 +8433,6 @@ fn aiur_fn_46( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_46] = [__v_24]; record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8734,7 +8462,6 @@ fn aiur_fn_47( 1u64 => { let __ret: [G; OUT_47] = [__v_1]; record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8754,7 +8481,6 @@ fn aiur_fn_47( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_47] = [__v_15]; record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8784,7 +8510,6 @@ fn aiur_fn_48( 1u64 => { let __ret: [G; OUT_48] = [__v_1]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -8794,7 +8519,6 @@ fn aiur_fn_48( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_48] = [__v_6]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8820,37 +8544,33 @@ fn aiur_fn_49( 0u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(3); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_49] = [__v_4]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -8932,10 +8652,9 @@ fn aiur_fn_50( let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_50] = [__v_54]; record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8989,7 +8708,6 @@ fn aiur_fn_51( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_29]; record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9024,7 +8742,6 @@ fn aiur_fn_52( 1u64 => { let __ret: [G; OUT_52] = [__v_1]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9034,7 +8751,6 @@ fn aiur_fn_52( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_14]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9149,10 +8865,9 @@ fn aiur_fn_53( let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_53] = [__v_83]; record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9206,10 +8921,9 @@ fn aiur_fn_54( let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_54] = [__v_32]; record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9266,7 +8980,6 @@ fn aiur_fn_55( let __v_31: G = __r_arr[0]; let __ret: [G; OUT_55] = [__v_31]; record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9350,10 +9063,9 @@ fn aiur_fn_56( let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_56] = [__v_59]; record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9413,7 +9125,6 @@ fn aiur_fn_57( 1u64 => { let __ret: [G; OUT_57] = [__v_1]; record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9423,7 +9134,6 @@ fn aiur_fn_57( let __v_39: G = __r_arr[0]; let __ret: [G; OUT_57] = [__v_39]; record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9514,10 +9224,9 @@ fn aiur_fn_58( let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_58] = [__v_61]; record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9552,7 +9261,6 @@ fn aiur_fn_59( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_59] = [__v_11]; record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9597,7 +9305,6 @@ fn aiur_fn_60( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_20]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9666,10 +9373,9 @@ fn aiur_fn_61( let __v_47: G = G::from_u64(0); let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_61] = [__v_49]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -9677,10 +9383,9 @@ fn aiur_fn_61( let __v_47: G = G::from_u64(1); let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_61] = [__v_49]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -9688,10 +9393,9 @@ fn aiur_fn_61( let __v_47: G = G::from_u64(2); let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_61] = [__v_49]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9765,7 +9469,6 @@ fn aiur_fn_62( 1u64 => { let __ret: [G; OUT_62] = [__v_1]; record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9775,7 +9478,6 @@ fn aiur_fn_62( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_62] = [__v_50]; record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9847,7 +9549,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -9855,7 +9556,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -9863,7 +9563,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -9871,7 +9570,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -9879,7 +9577,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -9887,7 +9584,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -9895,7 +9591,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -9903,7 +9598,6 @@ fn aiur_fn_63( let __v_46: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_46]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9940,7 +9634,6 @@ fn aiur_fn_64( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_64] = [__v_11]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -9972,7 +9665,6 @@ fn aiur_fn_65( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_11]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10004,7 +9696,6 @@ fn aiur_fn_66( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_11]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10094,7 +9785,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10113,7 +9803,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -10132,7 +9821,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -10151,7 +9839,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -10170,7 +9857,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -10189,7 +9875,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -10208,7 +9893,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -10227,7 +9911,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -10246,7 +9929,6 @@ fn aiur_fn_67( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_62]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10277,17 +9959,15 @@ fn aiur_fn_68( 0u64 => { let __ret: [G; OUT_68] = [__v_2, __v_3]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_68] = [__v_4, __v_7]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10321,7 +10001,6 @@ fn aiur_fn_69( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_69] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10345,7 +10024,6 @@ fn aiur_fn_69( let __v_15: G = __r_arr[8]; let __ret: [G; OUT_69] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10412,7 +10090,6 @@ fn aiur_fn_70( let __v_36: G = G::from_u64(0); let __ret: [G; OUT_70] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10436,7 +10113,6 @@ fn aiur_fn_70( let __v_43: G = __r_arr[8]; let __ret: [G; OUT_70] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10500,7 +10176,6 @@ fn aiur_fn_71( let __v_33: G = G::from_u64(0); let __ret: [G; OUT_71] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10524,7 +10199,6 @@ fn aiur_fn_71( } let __ret: [G; OUT_71] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10588,7 +10262,6 @@ fn aiur_fn_72( let __v_33: G = G::from_u64(0); let __ret: [G; OUT_72] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10606,7 +10279,6 @@ fn aiur_fn_72( let __v_37: G = __r_arr[8]; let __ret: [G; OUT_72] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10643,10 +10315,9 @@ fn aiur_fn_73( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_73] = [__v_12, __v_0]; record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10673,10 +10344,9 @@ fn aiur_fn_73( let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_73] = [__v_30, __v_28]; record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10712,7 +10382,6 @@ fn aiur_fn_74( 1u64 => { let __ret: [G; OUT_74] = [__v_0, __v_1]; record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10721,7 +10390,7 @@ fn aiur_fn_74( let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; @@ -10736,7 +10405,6 @@ fn aiur_fn_74( let __v_25: G = __r_arr[1]; let __ret: [G; OUT_74] = [__v_24, __v_25]; record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10774,7 +10442,6 @@ fn aiur_fn_75( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_75] = [__v_10, __v_11]; record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10795,10 +10462,9 @@ fn aiur_fn_75( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(8); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_75] = [__v_24, __v_21]; record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10836,7 +10502,6 @@ fn aiur_fn_76( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_76] = [__v_10, __v_11]; record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10857,10 +10522,9 @@ fn aiur_fn_76( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(9); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_76] = [__v_24, __v_21]; record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10896,19 +10560,17 @@ fn aiur_fn_77( 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -10927,10 +10589,9 @@ fn aiur_fn_77( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_24, __v_21]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -10949,10 +10610,9 @@ fn aiur_fn_77( let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_24, __v_21]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -10970,28 +10630,25 @@ fn aiur_fn_77( let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(4); - let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_23, __v_21]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -11009,7 +10666,6 @@ fn aiur_fn_77( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_15, __v_16]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -11024,7 +10680,6 @@ fn aiur_fn_77( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_13, __v_14]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -11039,7 +10694,6 @@ fn aiur_fn_77( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_13, __v_14]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -11048,16 +10702,14 @@ fn aiur_fn_77( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_77] = [__v_11, __v_12]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { let __v_11: G = G::from_u64(11); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_77] = [__v_13, __v_10]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11097,10 +10749,9 @@ fn aiur_fn_78( let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(10); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_78] = [__v_17, __v_14]; record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11138,7 +10789,6 @@ fn aiur_fn_79( 1u64 => { let __ret: [G; OUT_79] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11162,11 +10812,10 @@ fn aiur_fn_79( let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_37: G = G::from_u64(0); let __ret: [G; OUT_79] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11208,7 +10857,6 @@ fn aiur_fn_80( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11235,7 +10883,6 @@ fn aiur_fn_80( let __v_30: G = __r_arr[8]; let __ret: [G; OUT_80] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11267,12 +10914,11 @@ fn aiur_fn_80( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(2); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -11299,19 +10945,17 @@ fn aiur_fn_80( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(3); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11524,10 +11168,9 @@ fn aiur_fn_81( let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_81] = [__v_97, __v_96]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11717,10 +11360,9 @@ fn aiur_fn_82( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_82] = [__v_12, __v_0]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11740,10 +11382,9 @@ fn aiur_fn_82( let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_82] = [__v_23, __v_21]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11778,10 +11419,9 @@ fn aiur_fn_83( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_83] = [__v_12, __v_0]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11809,11 +11449,10 @@ fn aiur_fn_83( let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_83] = [__v_32, __v_29]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11848,10 +11487,9 @@ fn aiur_fn_84( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_84] = [__v_12, __v_0]; record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11871,10 +11509,9 @@ fn aiur_fn_84( let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_84] = [__v_23, __v_21]; record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11910,7 +11547,6 @@ fn aiur_fn_85( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_10, __v_11]; record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11941,7 +11577,6 @@ fn aiur_fn_86( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_86] = [__v_10, __v_11]; record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11972,7 +11607,6 @@ fn aiur_fn_87( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_87] = [__v_10, __v_11]; record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11994,7 +11628,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -12002,7 +11635,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -12010,7 +11642,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(2); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -12018,7 +11649,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -12026,7 +11656,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -12034,7 +11663,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(2); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -12042,7 +11670,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -12050,7 +11677,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -12058,7 +11684,6 @@ fn aiur_fn_88( let __v_2: G = G::from_u64(2); let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12103,7 +11728,6 @@ fn aiur_fn_89( let __v_17: G = __r_arr[1]; let __ret: [G; OUT_89] = [__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[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12134,7 +11758,6 @@ fn aiur_fn_90( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_90] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12164,10 +11787,9 @@ fn aiur_fn_91( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_91] = [__v_12, __v_0]; record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12195,10 +11817,9 @@ fn aiur_fn_91( 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; 11] = [__v_30, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_28]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 11] = [__v_30, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_28]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_91] = [__v_31, __v_29]; record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12299,7 +11920,6 @@ fn aiur_fn_92( let __v_68: G = __r_arr[1]; let __ret: [G; OUT_92] = [__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[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12323,7 +11943,6 @@ fn aiur_fn_93( } let __ret: [G; OUT_93] = []; record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12358,7 +11977,6 @@ fn aiur_fn_94( let __v_13: G = __r_arr[1]; let __ret: [G; OUT_94] = [__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[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12379,28 +11997,24 @@ fn aiur_fn_95( let __v_1: G = G::from_u64(0); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_95] = [__v_1]; record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12441,7 +12055,6 @@ fn aiur_fn_96( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_96] = [__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[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12506,7 +12119,6 @@ fn aiur_fn_97( let __v_40: G = __r_arr[1]; let __ret: [G; OUT_97] = [__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[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12536,10 +12148,9 @@ fn aiur_fn_98( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_98] = [__v_12, __v_0]; record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12592,10 +12203,9 @@ fn aiur_fn_98( let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_98] = [__v_56, __v_54]; record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12676,7 +12286,6 @@ fn aiur_fn_99( let __v_50: G = __r_arr[1]; let __ret: [G; OUT_99] = [__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[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12707,7 +12316,6 @@ fn aiur_fn_100( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_100] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12748,7 +12356,6 @@ fn aiur_fn_101( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_101] = [__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[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12787,7 +12394,6 @@ fn aiur_fn_102( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -12824,7 +12430,6 @@ fn aiur_fn_102( let __v_32: G = G::from_u64(0); let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -12877,7 +12482,6 @@ fn aiur_fn_102( let __v_48: G = G::from_u64(2); let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12912,10 +12516,9 @@ fn aiur_fn_103( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_103] = [__v_12, __v_0]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12979,10 +12582,9 @@ fn aiur_fn_103( let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_103] = [__v_67, __v_65]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13024,7 +12626,6 @@ fn aiur_fn_104( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -13077,7 +12678,6 @@ fn aiur_fn_104( let __v_47: G = G::from_u64(1); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -13097,7 +12697,6 @@ fn aiur_fn_104( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -13117,7 +12716,6 @@ fn aiur_fn_104( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -13144,7 +12742,6 @@ fn aiur_fn_104( let __v_21: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -13163,7 +12760,6 @@ fn aiur_fn_104( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -13182,7 +12778,6 @@ fn aiur_fn_104( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -13201,7 +12796,6 @@ fn aiur_fn_104( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13240,7 +12834,6 @@ fn aiur_fn_105( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { @@ -13303,7 +12896,6 @@ fn aiur_fn_105( let __v_62: G = __r_arr[45]; let __ret: [G; OUT_105] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13393,7 +12985,6 @@ fn aiur_fn_106( let __v_62: G = __r_arr[1]; let __ret: [G; OUT_106] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_57, __v_59, __v_61, __v_62]; record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13423,16 +13014,14 @@ fn aiur_fn_107( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_5, __v_7]; record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_107] = [__v_0, __v_7]; record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13474,11 +13063,10 @@ fn aiur_fn_108( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_108] = [__v_23]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13503,20 +13091,18 @@ fn aiur_fn_108( match __v_27.as_canonical_u64() { 0u64 => { let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_108] = [__v_29]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_108] = [__v_30]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13558,7 +13144,6 @@ fn aiur_fn_109( 0u64 => { let __ret: [G; OUT_109] = [__v_1]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13566,7 +13151,6 @@ fn aiur_fn_109( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_13]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13589,7 +13173,6 @@ fn aiur_fn_109( 0u64 => { let __ret: [G; OUT_109] = [__v_0]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13597,7 +13180,6 @@ fn aiur_fn_109( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_23]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13634,10 +13216,9 @@ fn aiur_fn_109( let __v_49: G = G::from_u64(0); let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_109] = [__v_51]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13669,7 +13250,6 @@ fn aiur_fn_110( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_3]; record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13754,7 +13334,6 @@ fn aiur_fn_111( let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_111] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13800,10 +13379,9 @@ fn aiur_fn_112( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_112] = [__v_25, __v_2]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13813,20 +13391,18 @@ fn aiur_fn_112( 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_112] = [__v_26, __v_2]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(1); let __ret: [G; OUT_112] = [__v_26, __v_27]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13855,7 +13431,6 @@ fn aiur_fn_112( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_0, __v_23]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13879,15 +13454,14 @@ fn aiur_fn_112( let __v_39: G = __r_arr[8]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_112] = [__v_46, __v_44]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13925,10 +13499,9 @@ fn aiur_fn_112( let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_112] = [__v_52, __v_50]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13969,7 +13542,6 @@ fn aiur_fn_113( 1u64 => { let __ret: [G; OUT_113] = []; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13980,7 +13552,6 @@ fn aiur_fn_113( let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_113] = []; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14016,10 +13587,9 @@ fn aiur_fn_114( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_114] = [__v_13]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14044,21 +13614,19 @@ fn aiur_fn_114( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_114] = [__v_25]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_114] = [__v_27]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14068,10 +13636,9 @@ fn aiur_fn_114( }, _ => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_114] = [__v_23]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14103,10 +13670,9 @@ fn aiur_fn_115( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_115] = [__v_7]; record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14114,7 +13680,6 @@ fn aiur_fn_115( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_5]; record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14154,14 +13719,12 @@ fn aiur_fn_116( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_116] = [__v_13]; record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_13]; record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14190,13 +13753,12 @@ fn aiur_fn_117( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_14]; record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14219,7 +13781,6 @@ fn aiur_fn_118( 1u64 => { let __ret: [G; OUT_118] = [__v_0, __v_1]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14232,7 +13793,6 @@ fn aiur_fn_118( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_118] = [__v_8, __v_9]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14263,7 +13823,6 @@ fn aiur_fn_119( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_119] = [__v_2, __v_5, __v_6]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14753,7 +14312,6 @@ fn aiur_fn_120( } let __ret: [G; OUT_120] = [__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[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14772,13 +14330,12 @@ fn aiur_fn_121( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_6]; record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14812,7 +14369,6 @@ fn aiur_fn_122( 1u64 => { let __ret: [G; OUT_122] = [__v_2]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14826,7 +14382,7 @@ fn aiur_fn_122( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; @@ -14839,7 +14395,6 @@ fn aiur_fn_122( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_122] = [__v_30]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14896,7 +14451,6 @@ fn aiur_fn_123( 1u64 => { let __ret: [G; OUT_123] = [__v_17]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14904,7 +14458,6 @@ fn aiur_fn_123( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_29]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14963,7 +14516,6 @@ fn aiur_fn_123( let __v_70: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_70]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14989,7 +14541,6 @@ fn aiur_fn_124( 0u64 => { let __ret: [G; OUT_124] = [__v_0]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15002,14 +14553,13 @@ fn aiur_fn_124( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_14]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15045,14 +14595,12 @@ fn aiur_fn_125( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_125] = [__v_12]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_12]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15103,7 +14651,6 @@ fn aiur_fn_126( } let __ret: [G; OUT_126] = [__v_4, __v_5]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15117,7 +14664,6 @@ fn aiur_fn_126( } let __ret: [G; OUT_126] = [__v_4, __v_5]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15144,7 +14690,6 @@ fn aiur_fn_127( let __v_3: G = __r_arr[1]; let __ret: [G; OUT_127] = [__v_2]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15166,7 +14711,6 @@ fn aiur_fn_128( let __v_3: G = __r_arr[1]; let __ret: [G; OUT_128] = [__v_3]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15189,7 +14733,6 @@ fn aiur_fn_129( 1u64 => { let __ret: [G; OUT_129] = [__v_0]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15199,7 +14742,6 @@ fn aiur_fn_129( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_129] = [__v_4]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15236,11 +14778,10 @@ fn aiur_fn_130( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_130] = [__v_15]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15255,8 +14796,8 @@ fn aiur_fn_130( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; @@ -15274,7 +14815,6 @@ fn aiur_fn_130( 1u64 => { let __ret: [G; OUT_130] = [__v_21]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15282,7 +14822,6 @@ fn aiur_fn_130( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_130] = [__v_23]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15333,7 +14872,6 @@ fn aiur_fn_131( 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_131] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15374,7 +14912,6 @@ fn aiur_fn_132( 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_132] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15415,7 +14952,6 @@ fn aiur_fn_133( let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; let __ret: [G; OUT_133] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15447,10 +14983,9 @@ fn aiur_fn_134( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_134] = [__v_14]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15469,10 +15004,9 @@ fn aiur_fn_134( 1u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_134] = [__v_24]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15488,10 +15022,9 @@ fn aiur_fn_134( let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_134] = [__v_32]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15533,7 +15066,6 @@ fn aiur_fn_135( 1u64 => { let __ret: [G; OUT_135] = [__v_1]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15552,7 +15084,6 @@ fn aiur_fn_135( 1u64 => { let __ret: [G; OUT_135] = [__v_0]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15568,10 +15099,9 @@ fn aiur_fn_135( let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_135] = [__v_32]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15613,7 +15143,6 @@ fn aiur_fn_136( 1u64 => { let __ret: [G; OUT_136] = [__v_1]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15632,7 +15161,6 @@ fn aiur_fn_136( 1u64 => { let __ret: [G; OUT_136] = [__v_0]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15648,10 +15176,9 @@ fn aiur_fn_136( let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_136] = [__v_32]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15689,15 +15216,14 @@ fn aiur_fn_137( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_16]; record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15725,15 +15251,14 @@ fn aiur_fn_138( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_16]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15780,10 +15305,9 @@ fn aiur_fn_139( let __v_29: G = G::from_u64(70); let __v_30: G = G::from_u64(125); let __v_31: G = G::from_u64(182); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_139] = [__v_32]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15830,10 +15354,9 @@ fn aiur_fn_140( let __v_29: G = G::from_u64(186); let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(110); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_140] = [__v_32]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15880,10 +15403,9 @@ fn aiur_fn_141( let __v_29: G = G::from_u64(89); let __v_30: G = G::from_u64(76); let __v_31: G = G::from_u64(136); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_141] = [__v_32]; record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15930,10 +15452,9 @@ fn aiur_fn_142( let __v_29: G = G::from_u64(132); let __v_30: G = G::from_u64(201); let __v_31: G = G::from_u64(105); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15980,10 +15501,9 @@ fn aiur_fn_143( let __v_29: G = G::from_u64(75); let __v_30: G = G::from_u64(114); let __v_31: G = G::from_u64(176); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_143] = [__v_32]; record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16030,10 +15550,9 @@ fn aiur_fn_144( let __v_29: G = G::from_u64(79); let __v_30: G = G::from_u64(150); let __v_31: G = G::from_u64(217); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_144] = [__v_32]; record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16080,10 +15599,9 @@ fn aiur_fn_145( let __v_29: G = G::from_u64(73); let __v_30: G = G::from_u64(161); let __v_31: G = G::from_u64(207); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_145] = [__v_32]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16130,10 +15648,9 @@ fn aiur_fn_146( let __v_29: G = G::from_u64(17); let __v_30: G = G::from_u64(167); let __v_31: G = G::from_u64(151); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_146] = [__v_32]; record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16180,10 +15697,9 @@ fn aiur_fn_147( let __v_29: G = G::from_u64(65); let __v_30: G = G::from_u64(161); let __v_31: G = G::from_u64(175); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_147] = [__v_32]; record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16230,10 +15746,9 @@ fn aiur_fn_148( let __v_29: G = G::from_u64(34); let __v_30: G = G::from_u64(83); let __v_31: G = G::from_u64(98); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_148] = [__v_32]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16280,10 +15795,9 @@ fn aiur_fn_149( let __v_29: G = G::from_u64(5); let __v_30: G = G::from_u64(142); let __v_31: G = G::from_u64(248); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_32]; record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16330,10 +15844,9 @@ fn aiur_fn_150( let __v_29: G = G::from_u64(78); let __v_30: G = G::from_u64(243); let __v_31: G = G::from_u64(151); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_150] = [__v_32]; record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16380,10 +15893,9 @@ fn aiur_fn_151( let __v_29: G = G::from_u64(86); let __v_30: G = G::from_u64(237); let __v_31: G = G::from_u64(41); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_151] = [__v_32]; record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16430,10 +15942,9 @@ fn aiur_fn_152( let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(217); let __v_31: G = G::from_u64(84); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_152] = [__v_32]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16480,10 +15991,9 @@ fn aiur_fn_153( let __v_29: G = G::from_u64(169); let __v_30: G = G::from_u64(186); 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_153] = [__v_32]; record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16530,10 +16040,9 @@ fn aiur_fn_154( let __v_29: G = G::from_u64(78); 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_154] = [__v_32]; record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16580,10 +16089,9 @@ fn aiur_fn_155( let __v_29: G = G::from_u64(239); let __v_30: G = G::from_u64(43); let __v_31: G = G::from_u64(248); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_155] = [__v_32]; record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16630,10 +16138,9 @@ fn aiur_fn_156( let __v_29: G = G::from_u64(240); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(98); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_156] = [__v_32]; record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16680,10 +16187,9 @@ fn aiur_fn_157( let __v_29: G = G::from_u64(244); let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_157] = [__v_32]; record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16730,10 +16236,9 @@ fn aiur_fn_158( let __v_29: G = G::from_u64(35); let __v_30: G = G::from_u64(118); let __v_31: G = G::from_u64(216); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_158] = [__v_32]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16780,10 +16285,9 @@ fn aiur_fn_159( let __v_29: G = G::from_u64(127); let __v_30: G = G::from_u64(64); let __v_31: G = G::from_u64(18); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_159] = [__v_32]; record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16830,10 +16334,9 @@ fn aiur_fn_160( let __v_29: G = G::from_u64(169); let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(120); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_160] = [__v_32]; record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16880,10 +16383,9 @@ fn aiur_fn_161( let __v_29: G = G::from_u64(40); let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(96); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_161] = [__v_32]; record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16930,10 +16432,9 @@ fn aiur_fn_162( let __v_29: G = G::from_u64(228); let __v_30: G = G::from_u64(96); let __v_31: G = G::from_u64(146); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_162] = [__v_32]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16980,10 +16481,9 @@ fn aiur_fn_163( let __v_29: G = G::from_u64(64); let __v_30: G = G::from_u64(232); let __v_31: G = G::from_u64(95); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_163] = [__v_32]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17030,10 +16530,9 @@ fn aiur_fn_164( let __v_29: G = G::from_u64(41); let __v_30: G = G::from_u64(25); let __v_31: G = G::from_u64(205); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_164] = [__v_32]; record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17080,10 +16579,9 @@ fn aiur_fn_165( let __v_29: G = G::from_u64(118); let __v_30: G = G::from_u64(105); let __v_31: G = G::from_u64(91); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_165] = [__v_32]; record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17130,10 +16628,9 @@ fn aiur_fn_166( let __v_29: G = G::from_u64(113); let __v_30: G = G::from_u64(15); let __v_31: G = G::from_u64(235); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_166] = [__v_32]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17158,7 +16655,6 @@ fn aiur_fn_167( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_3]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17171,7 +16667,6 @@ fn aiur_fn_167( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_5]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17184,7 +16679,6 @@ fn aiur_fn_167( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_7]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17197,7 +16691,6 @@ fn aiur_fn_167( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_9]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17210,7 +16703,6 @@ fn aiur_fn_167( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_11]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17223,14 +16715,12 @@ fn aiur_fn_167( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_167] = [__v_13]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_167] = [__v_13]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17268,15 +16758,14 @@ fn aiur_fn_168( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_168] = [__v_16]; record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17302,15 +16791,14 @@ fn aiur_fn_169( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_169] = [__v_16]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17339,7 +16827,6 @@ fn aiur_fn_170( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_5, __v_6]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17354,7 +16841,6 @@ fn aiur_fn_170( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_7, __v_8]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17369,7 +16855,6 @@ fn aiur_fn_170( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_9, __v_10]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17384,7 +16869,6 @@ fn aiur_fn_170( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_11, __v_12]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17403,10 +16887,9 @@ fn aiur_fn_170( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_170] = [__v_16, __v_20]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17420,10 +16903,9 @@ fn aiur_fn_170( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_170] = [__v_19, __v_23]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17439,7 +16921,6 @@ fn aiur_fn_170( let __v_23: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_22, __v_23]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17448,7 +16929,6 @@ fn aiur_fn_170( let __v_23: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_22, __v_23]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17488,10 +16968,9 @@ fn aiur_fn_171( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_171] = [__v_4, __v_8]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17519,7 +16998,6 @@ fn aiur_fn_171( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_14, __v_15]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17527,10 +17005,9 @@ fn aiur_fn_171( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_171] = [__v_14, __v_18]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17540,10 +17017,9 @@ fn aiur_fn_171( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_171] = [__v_12, __v_16]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17573,10 +17049,9 @@ fn aiur_fn_172( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_172] = [__v_4, __v_8]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17604,7 +17079,6 @@ fn aiur_fn_172( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_14, __v_15]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17619,7 +17093,6 @@ fn aiur_fn_172( let __v_17: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_16, __v_17]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17627,10 +17100,9 @@ fn aiur_fn_172( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_172] = [__v_16, __v_20]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17642,10 +17114,9 @@ fn aiur_fn_172( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_172] = [__v_12, __v_16]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17687,17 +17158,15 @@ fn aiur_fn_173( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_173] = [__v_10, __v_14]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_173] = [__v_10, __v_0]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17707,10 +17176,9 @@ fn aiur_fn_173( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_173] = [__v_5, __v_9]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17740,7 +17208,6 @@ fn aiur_fn_174( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_174] = [__v_5, __v_0]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17748,10 +17215,9 @@ fn aiur_fn_174( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_174] = [__v_5, __v_9]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17761,10 +17227,9 @@ fn aiur_fn_174( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_174] = [__v_5, __v_9]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -17813,10 +17278,9 @@ fn aiur_fn_175( let __v_29: G = G::from_u64(157); let __v_30: G = G::from_u64(228); let __v_31: G = G::from_u64(228); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_175] = [__v_32]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17863,10 +17327,9 @@ fn aiur_fn_176( let __v_29: G = G::from_u64(89); let __v_30: G = G::from_u64(165); let __v_31: G = G::from_u64(116); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_32]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17913,10 +17376,9 @@ fn aiur_fn_177( let __v_29: G = G::from_u64(66); let __v_30: G = G::from_u64(62); let __v_31: G = G::from_u64(174); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_177] = [__v_32]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -17963,10 +17425,9 @@ fn aiur_fn_178( let __v_29: G = G::from_u64(3); let __v_30: G = G::from_u64(61); let __v_31: G = G::from_u64(116); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_178] = [__v_32]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18013,10 +17474,9 @@ fn aiur_fn_179( let __v_29: G = G::from_u64(115); let __v_30: G = G::from_u64(55); let __v_31: G = G::from_u64(35); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_179] = [__v_32]; record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18063,10 +17523,9 @@ fn aiur_fn_180( let __v_29: G = G::from_u64(61); let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(18); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18091,7 +17550,6 @@ fn aiur_fn_181( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_181] = [__v_3]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18104,7 +17562,6 @@ fn aiur_fn_181( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_181] = [__v_5]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18117,14 +17574,12 @@ fn aiur_fn_181( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_181] = [__v_7]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_181] = [__v_7]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18153,12 +17608,11 @@ fn aiur_fn_182( let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_182] = [__v_7]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18167,12 +17621,11 @@ fn aiur_fn_182( let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_182] = [__v_7]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18200,10 +17653,9 @@ fn aiur_fn_183( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_183] = [__v_5, __v_8]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -18215,10 +17667,9 @@ fn aiur_fn_183( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_183] = [__v_7, __v_10]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -18230,10 +17681,9 @@ fn aiur_fn_183( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_183] = [__v_9, __v_12]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -18248,8 +17698,8 @@ fn aiur_fn_183( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); @@ -18259,7 +17709,6 @@ fn aiur_fn_183( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_23, __v_25]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18300,10 +17749,9 @@ fn aiur_fn_184( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_184] = [__v_4, __v_8]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18325,10 +17773,9 @@ fn aiur_fn_184( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_184] = [__v_12, __v_16]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -18341,10 +17788,9 @@ fn aiur_fn_184( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_184] = [__v_14, __v_18]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -18357,7 +17803,6 @@ fn aiur_fn_184( let __v_18: G = __r_arr[0]; let __ret: [G; OUT_184] = [__v_17, __v_18]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18395,10 +17840,9 @@ fn aiur_fn_185( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_185] = [__v_4, __v_8]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18425,10 +17869,9 @@ fn aiur_fn_185( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_185] = [__v_14, __v_18]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18442,10 +17885,9 @@ fn aiur_fn_185( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_185] = [__v_17, __v_21]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18472,10 +17914,9 @@ fn aiur_fn_185( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_185] = [__v_27, __v_31]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18489,10 +17930,9 @@ fn aiur_fn_185( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_185] = [__v_30, __v_34]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18510,16 +17950,15 @@ fn aiur_fn_185( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = G::from_u64(1); - let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __ret: [G; OUT_185] = [__v_45, __v_46]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18531,10 +17970,9 @@ fn aiur_fn_185( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_185] = [__v_25, __v_29]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18548,10 +17986,9 @@ fn aiur_fn_185( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_185] = [__v_12, __v_16]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18602,7 +18039,6 @@ fn aiur_fn_186( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_186] = [__v_12, __v_14, __v_16]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18610,14 +18046,13 @@ fn aiur_fn_186( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_186] = [__v_12, __v_16, __v_20]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18627,14 +18062,13 @@ fn aiur_fn_186( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_186] = [__v_9, __v_13, __v_17]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18644,14 +18078,13 @@ fn aiur_fn_186( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_186] = [__v_7, __v_11, __v_15]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18687,10 +18120,9 @@ fn aiur_fn_187( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_187] = [__v_8, __v_12]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18711,10 +18143,9 @@ fn aiur_fn_187( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_187] = [__v_15, __v_19]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -18723,7 +18154,6 @@ fn aiur_fn_187( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_187] = [__v_15, __v_16]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18747,7 +18177,6 @@ fn aiur_fn_187( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_187] = [__v_8, __v_9]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18762,7 +18191,6 @@ fn aiur_fn_187( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_187] = [__v_9, __v_10]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18770,10 +18198,9 @@ fn aiur_fn_187( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_187] = [__v_9, __v_13]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -18806,7 +18233,6 @@ fn aiur_fn_188( 1u64 => { let __ret: [G; OUT_188] = [__v_2]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -18818,7 +18244,6 @@ fn aiur_fn_188( 1u64 => { let __ret: [G; OUT_188] = [__v_2]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -18830,7 +18255,6 @@ fn aiur_fn_188( 1u64 => { let __ret: [G; OUT_188] = [__v_2]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -18841,12 +18265,11 @@ fn aiur_fn_188( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_188] = [__v_19]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -18887,7 +18310,6 @@ fn aiur_fn_189( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_189] = [__v_5]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18934,10 +18356,9 @@ fn aiur_fn_190( let __v_29: G = G::from_u64(149); let __v_30: G = G::from_u64(234); let __v_31: G = G::from_u64(147); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_190] = [__v_32]; record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -18984,10 +18405,9 @@ fn aiur_fn_191( let __v_29: G = G::from_u64(55); let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(15); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_191] = [__v_32]; record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19034,10 +18454,9 @@ fn aiur_fn_192( let __v_29: G = G::from_u64(228); let __v_30: G = G::from_u64(153); let __v_31: G = G::from_u64(6); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_192] = [__v_32]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19084,10 +18503,9 @@ fn aiur_fn_193( let __v_29: G = G::from_u64(196); let __v_30: G = G::from_u64(220); 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_193] = [__v_32]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19134,10 +18552,9 @@ fn aiur_fn_194( let __v_29: G = G::from_u64(239); let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(62); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_194] = [__v_32]; record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19184,10 +18601,9 @@ fn aiur_fn_195( let __v_29: G = G::from_u64(53); let __v_30: G = G::from_u64(2); let __v_31: G = G::from_u64(160); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_195] = [__v_32]; record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19234,10 +18650,9 @@ fn aiur_fn_196( let __v_29: G = G::from_u64(154); let __v_30: G = G::from_u64(76); let __v_31: G = G::from_u64(121); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_196] = [__v_32]; record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19284,10 +18699,9 @@ fn aiur_fn_197( let __v_29: G = G::from_u64(192); let __v_30: G = G::from_u64(146); let __v_31: G = G::from_u64(6); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_197] = [__v_32]; record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19334,10 +18748,9 @@ fn aiur_fn_198( let __v_29: G = G::from_u64(147); let __v_30: G = G::from_u64(109); let __v_31: G = G::from_u64(172); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_198] = [__v_32]; record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19384,10 +18797,9 @@ fn aiur_fn_199( let __v_29: G = G::from_u64(30); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(177); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_199] = [__v_32]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19434,10 +18846,9 @@ fn aiur_fn_200( let __v_29: G = G::from_u64(37); let __v_30: G = G::from_u64(7); 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_200] = [__v_32]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19484,10 +18895,9 @@ fn aiur_fn_201( let __v_29: G = G::from_u64(87); let __v_30: G = G::from_u64(147); let __v_31: G = G::from_u64(148); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_201] = [__v_32]; record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19534,10 +18944,9 @@ fn aiur_fn_202( let __v_29: G = G::from_u64(19); let __v_30: G = G::from_u64(200); 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_202] = [__v_32]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -19562,7 +18971,6 @@ fn aiur_fn_203( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_3]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19575,7 +18983,6 @@ fn aiur_fn_203( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_5]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19588,7 +18995,6 @@ fn aiur_fn_203( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_7]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19601,7 +19007,6 @@ fn aiur_fn_203( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_9]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19614,7 +19019,6 @@ fn aiur_fn_203( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_11]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19627,7 +19031,6 @@ fn aiur_fn_203( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_13]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19640,14 +19043,12 @@ fn aiur_fn_203( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_15]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_203] = [__v_15]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19701,10 +19102,9 @@ fn aiur_fn_204( let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_10, __v_14]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -19712,10 +19112,9 @@ fn aiur_fn_204( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_10, __v_14]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19728,10 +19127,9 @@ fn aiur_fn_204( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_6, __v_10]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19751,10 +19149,9 @@ fn aiur_fn_204( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_10, __v_14]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19780,10 +19177,9 @@ fn aiur_fn_204( let __v_20: G = G::from_u64(7); 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_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_19, __v_23]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19791,10 +19187,9 @@ fn aiur_fn_204( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_16, __v_20]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19804,10 +19199,9 @@ fn aiur_fn_204( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_16, __v_20]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19826,7 +19220,6 @@ fn aiur_fn_204( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_10, __v_11]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19841,7 +19234,6 @@ fn aiur_fn_204( let __v_13: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_12, __v_13]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19856,7 +19248,6 @@ fn aiur_fn_204( let __v_15: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_14, __v_15]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19871,7 +19262,6 @@ fn aiur_fn_204( let __v_17: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_16, __v_17]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19889,10 +19279,9 @@ fn aiur_fn_204( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_20, __v_24]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19926,10 +19315,9 @@ fn aiur_fn_204( let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_33, __v_37]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -19937,10 +19325,9 @@ fn aiur_fn_204( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_32, __v_36]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19950,10 +19337,9 @@ fn aiur_fn_204( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_32, __v_36]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19963,10 +19349,9 @@ fn aiur_fn_204( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_28, __v_32]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19976,10 +19361,9 @@ fn aiur_fn_204( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_28, __v_32]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -19991,10 +19375,9 @@ fn aiur_fn_204( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_204] = [__v_18, __v_22]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20034,10 +19417,9 @@ fn aiur_fn_205( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_205] = [__v_4, __v_8]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20060,22 +19442,21 @@ fn aiur_fn_205( let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(2); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_205] = [__v_23, __v_26]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20083,10 +19464,9 @@ fn aiur_fn_205( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_205] = [__v_10, __v_14]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20096,10 +19476,9 @@ fn aiur_fn_205( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_205] = [__v_10, __v_14]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20129,10 +19508,9 @@ fn aiur_fn_206( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_4, __v_8]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20160,12 +19538,11 @@ fn aiur_fn_206( let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_13, __v_20]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20173,10 +19550,9 @@ fn aiur_fn_206( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_13, __v_17]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20186,10 +19562,9 @@ fn aiur_fn_206( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_10, __v_14]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20199,10 +19574,9 @@ fn aiur_fn_206( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_10, __v_14]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20230,7 +19604,6 @@ fn aiur_fn_207( 1u64 => { let __ret: [G; OUT_207] = []; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -20240,7 +19613,6 @@ fn aiur_fn_207( let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_207] = []; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20266,7 +19638,6 @@ fn aiur_fn_208( let __v_2: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_2]; record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -20291,7 +19662,6 @@ fn aiur_fn_209( 1u64 => { let __ret: [G; OUT_209] = [__v_1]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -20302,7 +19672,6 @@ fn aiur_fn_209( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_7]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20335,7 +19704,6 @@ fn aiur_fn_210( let __v_6: G = (__v_0 - __v_5); let __ret: [G; OUT_210] = [__v_6]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20368,7 +19736,6 @@ fn aiur_fn_211( 1u64 => { let __ret: [G; OUT_211] = [__v_0, __v_1]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20395,7 +19762,6 @@ fn aiur_fn_211( let __v_16: G = (__v_14 + __v_15); let __ret: [G; OUT_211] = [__v_16, __v_10]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20438,7 +19804,6 @@ fn aiur_fn_211( 0u64 => { let __ret: [G; OUT_211] = [__v_25, __v_15]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20498,7 +19863,6 @@ fn aiur_fn_211( 0u64 => { let __ret: [G; OUT_211] = [__v_32, __v_18]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20547,60 +19911,59 @@ fn aiur_fn_212( let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(2); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(2); let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(2); let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(2); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(2); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_38: G = G::from_u64(3); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_212] = [__v_47]; record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -20627,7 +19990,6 @@ fn aiur_fn_213( 1u64 => { let __ret: [G; OUT_213] = [__v_1]; record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -20639,21 +20001,20 @@ fn aiur_fn_213( let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_213] = [__v_23]; record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20708,7 +20069,7 @@ fn aiur_fn_214( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -20725,18 +20086,16 @@ fn aiur_fn_214( let __v_33: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_33]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_34]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20744,7 +20103,6 @@ fn aiur_fn_214( _ => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20752,7 +20110,6 @@ fn aiur_fn_214( _ => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20760,7 +20117,6 @@ fn aiur_fn_214( _ => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20794,13 +20150,11 @@ fn aiur_fn_215( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_7]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_215] = [__v_0]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20808,7 +20162,6 @@ fn aiur_fn_215( _ => { let __ret: [G; OUT_215] = [__v_0]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20844,7 +20197,6 @@ fn aiur_fn_216( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_216] = [__v_2, __v_5, __v_8, __v_11]; record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -20892,11 +20244,10 @@ fn aiur_fn_217( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_217] = [__v_30]; record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -20938,20 +20289,18 @@ fn aiur_fn_218( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_218] = [__v_12, __v_15]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_218] = [__v_12, __v_15]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -20966,10 +20315,9 @@ fn aiur_fn_218( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_218] = [__v_13, __v_16]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -20988,10 +20336,9 @@ fn aiur_fn_218( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_218] = [__v_18, __v_21]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -21006,7 +20353,6 @@ fn aiur_fn_218( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_218] = [__v_22, __v_21]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -21015,7 +20361,6 @@ fn aiur_fn_218( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_22, __v_23]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21032,10 +20377,9 @@ fn aiur_fn_218( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_218] = [__v_14, __v_17]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21048,10 +20392,9 @@ fn aiur_fn_218( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_218] = [__v_9, __v_12]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21078,7 +20421,6 @@ fn aiur_fn_219( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_219] = [__v_4, __v_3]; record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21089,7 +20431,6 @@ fn aiur_fn_219( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_219] = [__v_5, __v_6]; record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21131,7 +20472,6 @@ fn aiur_fn_220( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_11, __v_12]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21149,7 +20489,6 @@ fn aiur_fn_220( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_220] = [__v_15, __v_16]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21157,7 +20496,6 @@ fn aiur_fn_220( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_15, __v_16]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21167,7 +20505,6 @@ fn aiur_fn_220( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_15, __v_16]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21179,7 +20516,6 @@ fn aiur_fn_220( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_9, __v_10]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21189,7 +20525,6 @@ fn aiur_fn_220( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_220] = [__v_5, __v_6]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21244,7 +20579,6 @@ fn aiur_fn_221( let __v_27: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_26, __v_27]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21261,7 +20595,6 @@ fn aiur_fn_221( let __v_34: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_34, __v_31]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21273,7 +20606,6 @@ fn aiur_fn_221( let __v_37: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_36, __v_37]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21284,7 +20616,6 @@ fn aiur_fn_221( let __v_38: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_38, __v_31]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21292,7 +20623,6 @@ fn aiur_fn_221( let __v_39: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_38, __v_39]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21308,7 +20638,6 @@ fn aiur_fn_221( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_21, __v_22]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21318,7 +20647,6 @@ fn aiur_fn_221( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_11, __v_12]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21343,7 +20671,6 @@ fn aiur_fn_222( 1u64 => { let __ret: [G; OUT_222] = [__v_0, __v_1]; record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21356,7 +20683,6 @@ fn aiur_fn_222( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_222] = [__v_8, __v_9]; record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21388,7 +20714,6 @@ fn aiur_fn_223( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_223] = [__v_2, __v_5, __v_8, __v_9]; record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -21459,10 +20784,9 @@ fn aiur_fn_224( match __v_36.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_224] = [__v_38]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21476,11 +20800,10 @@ fn aiur_fn_224( let __v_42: G = (__v_9 + __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_224] = [__v_46]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21497,12 +20820,11 @@ fn aiur_fn_224( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_224] = [__v_52]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21518,13 +20840,12 @@ fn aiur_fn_224( let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_224] = [__v_56]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21555,7 +20876,6 @@ fn aiur_fn_225( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_3]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21568,7 +20888,6 @@ fn aiur_fn_225( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_5]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21581,7 +20900,6 @@ fn aiur_fn_225( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_7]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21594,7 +20912,6 @@ fn aiur_fn_225( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_9]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21607,7 +20924,6 @@ fn aiur_fn_225( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_11]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21620,7 +20936,6 @@ fn aiur_fn_225( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_13]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21633,7 +20948,6 @@ fn aiur_fn_225( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_15]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21646,7 +20960,6 @@ fn aiur_fn_225( let __v_17: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_17]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21659,7 +20972,6 @@ fn aiur_fn_225( let __v_19: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_19]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21672,7 +20984,6 @@ fn aiur_fn_225( let __v_21: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_21]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21685,7 +20996,6 @@ fn aiur_fn_225( let __v_23: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_23]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21698,7 +21008,6 @@ fn aiur_fn_225( let __v_25: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_25]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21711,7 +21020,6 @@ fn aiur_fn_225( let __v_27: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_27]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21724,7 +21032,6 @@ fn aiur_fn_225( let __v_29: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_29]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21737,7 +21044,6 @@ fn aiur_fn_225( let __v_31: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_31]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -21750,14 +21056,12 @@ fn aiur_fn_225( let __v_33: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_33]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __ret: [G; OUT_225] = [__v_33]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21817,17 +21121,15 @@ fn aiur_fn_226( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_226] = [__v_5, __v_3]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_226] = [__v_5, __v_8]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21842,20 +21144,18 @@ fn aiur_fn_226( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_226] = [__v_7, __v_10]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_226] = [__v_7, __v_10]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21866,17 +21166,15 @@ fn aiur_fn_226( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_226] = [__v_5, __v_6]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_226] = [__v_5, __v_8]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21918,17 +21216,15 @@ fn aiur_fn_227( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_10, __v_11]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_227] = [__v_10, __v_13]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21937,10 +21233,9 @@ fn aiur_fn_227( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_227] = [__v_8, __v_11]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21949,10 +21244,9 @@ fn aiur_fn_227( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_227] = [__v_6, __v_9]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -21973,10 +21267,9 @@ fn aiur_fn_228( let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_228] = [__v_4]; record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -22001,18 +21294,16 @@ fn aiur_fn_229( 1u64 => { let __ret: [G; OUT_229] = [__v_0]; record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_229] = [__v_8]; record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22050,7 +21341,6 @@ fn aiur_fn_230( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_5, __v_8]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22069,7 +21359,6 @@ fn aiur_fn_230( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_7, __v_10]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22088,7 +21377,6 @@ fn aiur_fn_230( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_9, __v_12]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22107,7 +21395,6 @@ fn aiur_fn_230( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_11, __v_14]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22126,7 +21413,6 @@ fn aiur_fn_230( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_13, __v_16]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22145,7 +21431,6 @@ fn aiur_fn_230( let __v_18: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_15, __v_18]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22164,7 +21449,6 @@ fn aiur_fn_230( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_17, __v_20]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22183,7 +21467,6 @@ fn aiur_fn_230( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_19, __v_22]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22202,7 +21485,6 @@ fn aiur_fn_230( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_21, __v_24]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22221,7 +21503,6 @@ fn aiur_fn_230( let __v_26: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_23, __v_26]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22240,7 +21521,6 @@ fn aiur_fn_230( let __v_28: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_25, __v_28]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22259,7 +21539,6 @@ fn aiur_fn_230( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_27, __v_30]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22276,7 +21555,6 @@ fn aiur_fn_230( let __v_31: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_29, __v_31]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22293,7 +21571,6 @@ fn aiur_fn_230( let __v_33: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_31, __v_33]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22301,10 +21578,9 @@ fn aiur_fn_230( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_230] = [__v_31, __v_35]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22365,10 +21641,9 @@ fn aiur_fn_231( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_231] = [__v_8, __v_0, __v_11]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22396,17 +21671,15 @@ fn aiur_fn_231( let __v_19: G = G::from_u64(1); let __ret: [G; OUT_231] = [__v_19, __v_12, __v_17]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_231] = [__v_19, __v_0, __v_22]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22415,10 +21688,9 @@ fn aiur_fn_231( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_231] = [__v_19, __v_0, __v_22]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22427,10 +21699,9 @@ fn aiur_fn_231( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_231] = [__v_11, __v_0, __v_14]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22441,10 +21712,9 @@ fn aiur_fn_231( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_231] = [__v_6, __v_0, __v_9]; record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22474,8 +21744,8 @@ fn aiur_fn_232( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; @@ -22485,19 +21755,18 @@ fn aiur_fn_232( let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_232] = [__v_27]; record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22506,25 +21775,24 @@ fn aiur_fn_232( let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(7); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(3); let __v_37: G = G::from_u64(3); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_232] = [__v_44]; record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22551,7 +21819,6 @@ fn aiur_fn_233( 7u64 => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22579,7 +21846,6 @@ fn aiur_fn_233( 1u64 => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22587,7 +21853,6 @@ fn aiur_fn_233( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_233] = [__v_16]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22595,7 +21860,6 @@ fn aiur_fn_233( _ => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22603,7 +21867,6 @@ fn aiur_fn_233( _ => { let __ret: [G; OUT_233] = [__v_0]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22634,7 +21897,6 @@ fn aiur_fn_234( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_4, __v_5]; record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22643,23 +21905,22 @@ fn aiur_fn_234( let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_18, __v_19]; record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22710,7 +21971,6 @@ fn aiur_fn_235( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_17]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22733,14 +21993,12 @@ fn aiur_fn_235( let __v_26: G = G::from_bool((__v_23 == G::ZERO)); let __ret: [G; OUT_235] = [__v_26]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_26]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22749,7 +22007,6 @@ fn aiur_fn_235( let __v_20: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_20]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22760,7 +22017,6 @@ fn aiur_fn_235( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_15]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22769,7 +22025,6 @@ fn aiur_fn_235( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_9]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22778,7 +22033,6 @@ fn aiur_fn_235( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_235] = [__v_5]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22808,10 +22062,9 @@ fn aiur_fn_236( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_236] = [__v_7, __v_11]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22826,10 +22079,9 @@ fn aiur_fn_236( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_236] = [__v_10, __v_14]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -22846,10 +22098,9 @@ fn aiur_fn_236( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_236] = [__v_15, __v_19]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22873,7 +22124,6 @@ fn aiur_fn_236( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_236] = [__v_21, __v_24]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22882,7 +22132,6 @@ fn aiur_fn_236( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_236] = [__v_21, __v_22]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22931,10 +22180,9 @@ fn aiur_fn_237( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_237] = [__v_10, __v_14]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22958,7 +22206,6 @@ fn aiur_fn_237( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_237] = [__v_16, __v_19]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -22966,10 +22213,9 @@ fn aiur_fn_237( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_237] = [__v_14, __v_18]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -22987,10 +22233,9 @@ fn aiur_fn_237( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_237] = [__v_10, __v_14]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23016,7 +22261,6 @@ fn aiur_fn_237( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_237] = [__v_16, __v_20]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23024,10 +22268,9 @@ fn aiur_fn_237( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_237] = [__v_14, __v_18]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23040,7 +22283,6 @@ fn aiur_fn_237( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_237] = [__v_8, __v_9]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23070,10 +22312,9 @@ fn aiur_fn_238( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_238] = [__v_5, __v_9]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23106,7 +22347,6 @@ fn aiur_fn_238( let __v_18: G = __r_arr[0]; let __ret: [G; OUT_238] = [__v_17, __v_18]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23114,10 +22354,9 @@ fn aiur_fn_238( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_238] = [__v_15, __v_19]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23127,10 +22366,9 @@ fn aiur_fn_238( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_238] = [__v_13, __v_17]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23146,7 +22384,6 @@ fn aiur_fn_238( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_238] = [__v_13, __v_14]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23154,10 +22391,9 @@ fn aiur_fn_238( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_238] = [__v_13, __v_17]; record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23216,10 +22452,9 @@ fn aiur_fn_239( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_239] = [__v_22, __v_26]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23236,7 +22471,6 @@ fn aiur_fn_239( let __v_26: G = G::from_u64(2); let __ret: [G; OUT_239] = [__v_26, __v_25]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23244,10 +22478,9 @@ fn aiur_fn_239( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_239] = [__v_26, __v_30]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23258,7 +22491,6 @@ fn aiur_fn_239( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_239] = [__v_24, __v_25]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23284,22 +22516,21 @@ fn aiur_fn_240( let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_240] = [__v_17]; record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -23328,7 +22559,6 @@ fn aiur_fn_241( 8u64 => { let __ret: [G; OUT_241] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23340,7 +22570,6 @@ fn aiur_fn_241( 1u64 => { let __ret: [G; OUT_241] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -23358,7 +22587,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -23374,7 +22602,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -23390,7 +22617,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -23406,7 +22632,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -23422,7 +22647,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -23438,7 +22662,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -23454,7 +22677,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23470,7 +22692,6 @@ fn aiur_fn_241( let __v_21: G = __r_arr[7]; let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23500,7 +22721,6 @@ fn aiur_fn_242( 0u64 => { let __ret: [G; OUT_242] = [__v_0]; record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23512,10 +22732,9 @@ fn aiur_fn_242( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_242] = [__v_7]; record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -23525,7 +22744,6 @@ fn aiur_fn_242( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_242] = [__v_7]; record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23577,7 +22795,7 @@ fn aiur_fn_243( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_0 [__v_25]; }, _ => { @@ -23607,21 +22825,19 @@ fn aiur_fn_243( 1u64 => { let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); - let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_243] = [__v_37]; record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_243] = [__v_39]; record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23631,10 +22847,9 @@ fn aiur_fn_243( }, _ => { let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_243] = [__v_35]; record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -23666,10 +22881,9 @@ fn aiur_fn_244( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_244] = [__v_12]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -23677,10 +22891,9 @@ fn aiur_fn_244( let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -23689,10 +22902,9 @@ fn aiur_fn_244( let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -23701,10 +22913,9 @@ fn aiur_fn_244( let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -23712,10 +22923,9 @@ fn aiur_fn_244( let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_244] = [__v_13]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23752,10 +22962,9 @@ fn aiur_fn_245( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_245] = [__v_14]; record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -23768,10 +22977,9 @@ fn aiur_fn_245( let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_245] = [__v_17]; record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -23825,10 +23033,9 @@ fn aiur_fn_246( let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -23836,10 +23043,9 @@ fn aiur_fn_246( let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_26]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -23851,10 +23057,9 @@ fn aiur_fn_246( let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -23866,10 +23071,9 @@ fn aiur_fn_246( let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -23882,10 +23086,9 @@ fn aiur_fn_246( let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -23899,10 +23102,9 @@ fn aiur_fn_246( let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_29]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -23917,10 +23119,9 @@ fn aiur_fn_246( let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_30]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -23930,10 +23131,9 @@ fn aiur_fn_246( let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -23943,10 +23143,9 @@ fn aiur_fn_246( let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -23956,10 +23155,9 @@ fn aiur_fn_246( let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -23970,10 +23168,9 @@ fn aiur_fn_246( let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_246] = [__v_27]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { @@ -23991,7 +23188,6 @@ fn aiur_fn_246( let __v_28: G = __r_arr[0]; let __ret: [G; OUT_246] = [__v_28]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24047,7 +23243,6 @@ fn aiur_fn_247( let __v_21: G = G::from_u64(0); let __ret: [G; OUT_247] = [__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[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -24067,7 +23262,6 @@ fn aiur_fn_247( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_247] = [__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[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -24075,7 +23269,6 @@ fn aiur_fn_247( let __v_21: G = G::from_u64(0); let __ret: [G; OUT_247] = [__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[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24121,7 +23314,6 @@ fn aiur_fn_248( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_248] = [__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[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24162,7 +23354,6 @@ fn aiur_fn_249( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_249] = [__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[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24222,7 +23413,6 @@ fn aiur_fn_250( let __v_37: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_37]; record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -24232,7 +23422,6 @@ fn aiur_fn_250( let __v_39: G = (__v_37 + __v_38); let __ret: [G; OUT_250] = [__v_39]; record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24297,7 +23486,6 @@ fn aiur_fn_251( 0u64 => { let __ret: [G; OUT_251] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __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[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24340,7 +23528,6 @@ fn aiur_fn_251( let __v_73: G = __r_arr[33]; let __ret: [G; OUT_251] = [__v_40, __v_41, __v_42, __v_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[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24411,7 +23598,6 @@ fn aiur_fn_252( let __v_39: G = G::from_u64(0); let __ret: [G; OUT_252] = [__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[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24484,7 +23670,6 @@ fn aiur_fn_253( let __v_46: G = G::from_u64(0); let __ret: [G; OUT_253] = [__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[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24523,10 +23708,9 @@ fn aiur_fn_254( 1u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_254] = [__v_19]; record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -24541,10 +23725,9 @@ fn aiur_fn_254( let __v_21: G = (__v_5 + __v_20); let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_254] = [__v_23]; record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24636,7 +23819,6 @@ fn aiur_fn_255( let __v_58: G = __r_arr[0]; let __ret: [G; OUT_255] = [__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[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24762,7 +23944,6 @@ fn aiur_fn_256( } let __ret: [G; OUT_256] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_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[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -24826,7 +24007,6 @@ fn aiur_fn_257( 0u64 => { let __ret: [G; OUT_257] = [__v_39]; record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -24890,7 +24070,6 @@ fn aiur_fn_258( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_258] = [__v_37]; record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -24912,7 +24091,6 @@ fn aiur_fn_259( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -24921,14 +24099,12 @@ fn aiur_fn_259( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24939,14 +24115,12 @@ fn aiur_fn_259( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_259] = [__v_2]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -24990,10 +24164,9 @@ fn aiur_fn_260( 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_260] = [__v_17]; record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25001,7 +24174,6 @@ fn aiur_fn_260( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_15]; record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25084,15 +24256,15 @@ fn aiur_fn_261( 0u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_0 [__v_53]; }, _ => { let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_0 [__v_55]; }, } @@ -25113,16 +24285,15 @@ fn aiur_fn_261( let __v_60: G = __r_arr[9]; let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; - let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_261] = [__v_63]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; @@ -25136,16 +24307,15 @@ fn aiur_fn_261( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_261] = [__v_64]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; @@ -25159,10 +24329,9 @@ fn aiur_fn_261( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_261] = [__v_64]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -25172,7 +24341,6 @@ fn aiur_fn_261( let __v_49: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_49]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25186,7 +24354,6 @@ fn aiur_fn_261( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_50]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25202,7 +24369,6 @@ fn aiur_fn_261( let __v_51: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_51]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25216,7 +24382,6 @@ fn aiur_fn_261( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_50]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25225,8 +24390,8 @@ fn aiur_fn_261( let __v_49: G = G::from_u64(0); let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); - let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; @@ -25241,10 +24406,9 @@ fn aiur_fn_261( let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; - let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_261] = [__v_67]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25394,10 +24558,9 @@ fn aiur_fn_262( let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; - let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_262] = [__v_117]; record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25542,10 +24705,9 @@ fn aiur_fn_263( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_263] = [__v_108]; record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25728,10 +24890,9 @@ fn aiur_fn_264( let __v_140: G = __r_arr[9]; let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; - let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_264] = [__v_143]; record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -25878,10 +25039,9 @@ fn aiur_fn_265( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_265] = [__v_108]; record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -25964,7 +25124,6 @@ fn aiur_fn_266( 0u64 => { let __ret: [G; OUT_266] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26018,7 +25177,6 @@ fn aiur_fn_266( let __v_95: G = __r_arr[44]; let __ret: [G; OUT_266] = [__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[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26061,7 +25219,6 @@ fn aiur_fn_267( } 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].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -26202,23 +25359,22 @@ fn aiur_fn_268( let __v_100: G = __mc_out___mc_0[44]; let __v_101: G = G::from_u64(1); let __v_102: G = G::from_u64(1); - let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_107: G = G::from_u64(1); let __v_108: G = G::from_u64(1); - let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_110: G = G::from_u64(1); let __v_111: G = G::from_u64(1); - let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_114]; record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -26240,7 +25396,6 @@ fn aiur_fn_269( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_269] = [__v_3]; record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -26311,10 +25466,9 @@ fn aiur_fn_270( 1u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_270] = [__v_53]; record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26325,10 +25479,9 @@ fn aiur_fn_270( let __v_54: G = (__v_3 + __v_53); let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_270] = [__v_56]; record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26358,21 +25511,18 @@ fn aiur_fn_271( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -26387,14 +25537,12 @@ fn aiur_fn_271( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_271] = [__v_6]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_271] = [__v_6]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26403,7 +25551,6 @@ fn aiur_fn_271( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_271] = [__v_6]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26413,7 +25560,6 @@ fn aiur_fn_271( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_271] = [__v_4]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26450,14 +25596,12 @@ fn aiur_fn_272( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26473,14 +25617,12 @@ fn aiur_fn_272( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26499,14 +25641,12 @@ fn aiur_fn_272( let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_272] = [__v_10]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26525,14 +25665,12 @@ fn aiur_fn_272( let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_272] = [__v_10]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26548,14 +25686,12 @@ fn aiur_fn_272( let __v_9: G = G::from_bool((__v_8 == G::ZERO)); let __ret: [G; OUT_272] = [__v_9]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_8]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -26594,14 +25730,12 @@ fn aiur_fn_273( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_273] = [__v_8]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_273] = [__v_8]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26619,7 +25753,6 @@ fn aiur_fn_273( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_273] = [__v_8]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26629,7 +25762,6 @@ fn aiur_fn_273( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_273] = [__v_9]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26639,7 +25771,6 @@ fn aiur_fn_273( let __v_10: G = G::from_u64(2); let __ret: [G; OUT_273] = [__v_10]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26647,7 +25778,6 @@ fn aiur_fn_273( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_273] = [__v_10]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26693,7 +25823,6 @@ fn aiur_fn_274( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_274] = [__v_5]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26706,7 +25835,6 @@ fn aiur_fn_274( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_8]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26716,7 +25844,6 @@ fn aiur_fn_274( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26727,7 +25854,6 @@ fn aiur_fn_274( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_10]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26735,7 +25861,6 @@ fn aiur_fn_274( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_10]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26787,14 +25912,12 @@ fn aiur_fn_275( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26812,7 +25935,6 @@ fn aiur_fn_275( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26820,7 +25942,6 @@ fn aiur_fn_275( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_275] = [__v_8]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26857,11 +25978,10 @@ fn aiur_fn_276( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_276] = [__v_5, __v_10]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26870,10 +25990,9 @@ fn aiur_fn_276( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_276] = [__v_6, __v_8]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26883,7 +26002,6 @@ fn aiur_fn_276( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_276] = [__v_7, __v_1]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -26891,10 +26009,9 @@ fn aiur_fn_276( let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_276] = [__v_7, __v_10]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -26934,14 +26051,13 @@ fn aiur_fn_277( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_277] = [__v_11]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26954,11 +26070,10 @@ fn aiur_fn_277( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_277] = [__v_11]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26968,10 +26083,9 @@ fn aiur_fn_277( let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_277] = [__v_12]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -26979,17 +26093,15 @@ fn aiur_fn_277( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_277] = [__v_13]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_277] = [__v_0]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27043,14 +26155,12 @@ fn aiur_fn_278( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_278] = [__v_8]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_8]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27068,7 +26178,6 @@ fn aiur_fn_278( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_8]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27092,14 +26201,12 @@ fn aiur_fn_278( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_278] = [__v_14]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_14]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27108,7 +26215,6 @@ fn aiur_fn_278( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_278] = [__v_13]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27149,7 +26255,6 @@ fn aiur_fn_279( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_279] = [__v_4]; record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27165,13 +26270,11 @@ fn aiur_fn_279( 1u64 => { let __ret: [G; OUT_279] = [__v_5]; record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_279] = [__v_6]; record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27208,7 +26311,6 @@ fn aiur_fn_280( 1u64 => { let __ret: [G; OUT_280] = [__v_0]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27220,7 +26322,6 @@ fn aiur_fn_280( 1u64 => { let __ret: [G; OUT_280] = [__v_0]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27240,10 +26341,9 @@ fn aiur_fn_280( let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_280] = [__v_15]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27254,7 +26354,6 @@ fn aiur_fn_280( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_280] = [__v_14]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27264,10 +26363,9 @@ fn aiur_fn_280( let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_280] = [__v_17]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27275,7 +26373,6 @@ fn aiur_fn_280( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_280] = [__v_15]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27326,7 +26423,6 @@ fn aiur_fn_281( 0u64 => { let __ret: [G; OUT_281] = [__v_0]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -27340,13 +26436,11 @@ fn aiur_fn_281( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_281] = [__v_6]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_281] = [__v_0]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27359,7 +26453,6 @@ fn aiur_fn_281( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_281] = [__v_3]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27388,15 +26481,14 @@ fn aiur_fn_282( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_282] = [__v_14]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27414,17 +26506,15 @@ fn aiur_fn_282( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_282] = [__v_13]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_282] = [__v_0]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27436,22 +26526,20 @@ fn aiur_fn_282( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_282] = [__v_15]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_282] = [__v_12]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27488,19 +26576,18 @@ fn aiur_fn_283( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_283] = [__v_19]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27517,37 +26604,34 @@ fn aiur_fn_283( let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_283] = [__v_14]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_283] = [__v_20]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_283] = [__v_13]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27585,7 +26669,6 @@ fn aiur_fn_284( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_7]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -27595,7 +26678,6 @@ fn aiur_fn_284( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_9]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -27605,7 +26687,6 @@ fn aiur_fn_284( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_8]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -27613,7 +26694,6 @@ fn aiur_fn_284( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_7]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -27628,7 +26708,6 @@ fn aiur_fn_284( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_10]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27636,7 +26715,6 @@ fn aiur_fn_284( 0u64 => { let __ret: [G; OUT_284] = [__v_3]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27644,7 +26722,6 @@ fn aiur_fn_284( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_284] = [__v_9]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27686,7 +26763,6 @@ fn aiur_fn_285( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_8]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -27698,7 +26774,6 @@ fn aiur_fn_285( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_11]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -27708,7 +26783,6 @@ fn aiur_fn_285( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_9]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -27718,7 +26792,6 @@ fn aiur_fn_285( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_9]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -27735,7 +26808,6 @@ fn aiur_fn_285( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_12]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27755,7 +26827,6 @@ fn aiur_fn_285( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_11]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27790,7 +26861,6 @@ fn aiur_fn_286( 1u64 => { let __ret: [G; OUT_286] = [__v_0]; record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27799,10 +26869,9 @@ fn aiur_fn_286( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_286] = [__v_8]; record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27832,7 +26901,6 @@ fn aiur_fn_287( 1u64 => { let __ret: [G; OUT_287] = [__v_0]; record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -27856,7 +26924,6 @@ fn aiur_fn_287( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_287] = [__v_12]; record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -27949,12 +27016,11 @@ fn aiur_fn_287( } }; let __v_14: G = __mc_out___mc_3[0]; - let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_287] = [__v_16]; record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -27997,14 +27063,12 @@ fn aiur_fn_288( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_288] = [__v_8]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_8]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28022,7 +27086,6 @@ fn aiur_fn_288( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_8]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28053,14 +27116,12 @@ fn aiur_fn_288( let __v_17: G = __r_arr[0]; let __ret: [G; OUT_288] = [__v_17]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_17]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28072,7 +27133,6 @@ fn aiur_fn_288( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_16]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28081,7 +27141,6 @@ fn aiur_fn_288( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_15]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28124,7 +27183,6 @@ fn aiur_fn_289( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_289] = [__v_6]; record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28142,7 +27200,6 @@ fn aiur_fn_289( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_289] = [__v_10]; record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28168,7 +27225,6 @@ fn aiur_fn_289( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_289] = [__v_12]; record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28176,7 +27232,6 @@ fn aiur_fn_289( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_289] = [__v_12]; record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28216,7 +27271,6 @@ fn aiur_fn_290( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_290] = [__v_5]; record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28233,7 +27287,6 @@ fn aiur_fn_290( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_290] = [__v_10]; record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -28241,7 +27294,6 @@ fn aiur_fn_290( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_290] = [__v_10]; record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28281,7 +27333,6 @@ fn aiur_fn_291( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_291] = [__v_7]; record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28299,7 +27350,6 @@ fn aiur_fn_291( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_291] = [__v_11]; record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28310,7 +27360,6 @@ fn aiur_fn_291( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_291] = [__v_12]; record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28318,7 +27367,6 @@ fn aiur_fn_291( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_291] = [__v_12]; record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28359,7 +27407,6 @@ fn aiur_fn_292( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_292] = [__v_6]; record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28377,7 +27424,6 @@ fn aiur_fn_292( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_292] = [__v_10]; record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -28385,7 +27431,6 @@ fn aiur_fn_292( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_292] = [__v_10]; record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28398,7 +27443,6 @@ fn aiur_fn_292( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_292] = [__v_9]; record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28433,7 +27477,6 @@ fn aiur_fn_293( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_293] = [__v_5]; record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28461,7 +27504,6 @@ fn aiur_fn_293( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_9]; record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -28472,7 +27514,6 @@ fn aiur_fn_293( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_10]; record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -28480,7 +27521,6 @@ fn aiur_fn_293( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_10]; record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28524,7 +27564,6 @@ fn aiur_fn_294( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_294] = [__v_6]; record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28540,7 +27579,6 @@ fn aiur_fn_294( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_294] = [__v_9]; record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -28548,7 +27586,6 @@ fn aiur_fn_294( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_294] = [__v_9]; record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28579,19 +27616,19 @@ fn aiur_fn_295( let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; @@ -28599,7 +27636,6 @@ fn aiur_fn_295( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_295] = [__v_19]; record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -28623,7 +27659,6 @@ fn aiur_fn_296( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_296] = [__v_3]; record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28636,7 +27671,6 @@ fn aiur_fn_296( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_296] = [__v_6]; record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28648,7 +27682,6 @@ fn aiur_fn_296( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_296] = [__v_8]; record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28679,7 +27712,6 @@ fn aiur_fn_297( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_297] = [__v_3]; record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28691,7 +27723,6 @@ fn aiur_fn_297( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_297] = [__v_5]; record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28728,13 +27759,11 @@ fn aiur_fn_298( 1u64 => { let __ret: [G; OUT_298] = [__v_1]; record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_298] = [__v_0]; record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28747,7 +27776,6 @@ fn aiur_fn_298( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_298] = [__v_6]; record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28757,7 +27785,6 @@ fn aiur_fn_298( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_298] = [__v_4]; record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28782,7 +27809,6 @@ fn aiur_fn_299( 1u64 => { let __ret: [G; OUT_299] = [__v_0]; record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28794,7 +27820,6 @@ fn aiur_fn_299( 0u64 => { let __ret: [G; OUT_299] = [__v_1]; record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28806,7 +27831,6 @@ fn aiur_fn_299( 0u64 => { let __ret: [G; OUT_299] = [__v_0]; record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28816,7 +27840,6 @@ fn aiur_fn_299( 1u64 => { let __ret: [G; OUT_299] = [__v_1]; record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28826,7 +27849,6 @@ fn aiur_fn_299( 1u64 => { let __ret: [G; OUT_299] = [__v_0]; record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -28834,7 +27856,6 @@ fn aiur_fn_299( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_299] = [__v_11]; record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28876,7 +27897,6 @@ fn aiur_fn_300( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_300] = [__v_3]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -28895,14 +27915,12 @@ fn aiur_fn_300( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_300] = [__v_9]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_9]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28918,14 +27936,12 @@ fn aiur_fn_300( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_300] = [__v_9]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_9]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28944,14 +27960,12 @@ fn aiur_fn_300( let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_300] = [__v_11]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_9]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28970,14 +27984,12 @@ fn aiur_fn_300( let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_300] = [__v_11]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_9]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -28995,14 +28007,12 @@ fn aiur_fn_300( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_300] = [__v_10]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_10]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29011,7 +28021,6 @@ fn aiur_fn_300( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_9]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29050,7 +28059,6 @@ fn aiur_fn_301( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_301] = [__v_6]; record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -29058,7 +28066,6 @@ fn aiur_fn_301( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_301] = [__v_6]; record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29070,7 +28077,6 @@ fn aiur_fn_301( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_301] = [__v_5]; record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29106,13 +28112,11 @@ fn aiur_fn_302( 1u64 => { let __ret: [G; OUT_302] = [__v_1]; record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_302] = [__v_0]; record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29122,10 +28126,9 @@ fn aiur_fn_302( }, 0u64 => { let __v_9: G = G::from_u64(2); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_302] = [__v_10]; record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29156,7 +28159,6 @@ fn aiur_fn_303( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_303] = [__v_4, __v_5]; record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -29170,7 +28172,6 @@ fn aiur_fn_303( let __v_8: G = (__v_5 + __v_7); let __ret: [G; OUT_303] = [__v_6, __v_8]; record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29178,7 +28179,6 @@ fn aiur_fn_303( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_303] = [__v_6, __v_7]; record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29188,7 +28188,6 @@ fn aiur_fn_303( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_303] = [__v_4, __v_5]; record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29220,13 +28219,11 @@ fn aiur_fn_304( let __v_8: G = __r_arr[1]; let __ret: [G; OUT_304] = [__v_7, __v_8]; record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_304] = [__v_0, __v_1]; record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29253,10 +28250,9 @@ fn aiur_fn_305( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_305] = [__v_7]; record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -29264,7 +28260,6 @@ fn aiur_fn_305( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_305] = [__v_5]; record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29276,7 +28271,6 @@ fn aiur_fn_305( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_305] = [__v_6]; record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -29288,7 +28282,6 @@ fn aiur_fn_305( 0u64 => { let __ret: [G; OUT_305] = [__v_1]; record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29298,15 +28291,13 @@ fn aiur_fn_305( 1u64 => { let __ret: [G; OUT_305] = [__v_0]; record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_305] = [__v_11]; record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29344,19 +28335,17 @@ fn aiur_fn_306( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_306] = [__v_6]; record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_306] = [__v_6]; record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -29364,10 +28353,9 @@ fn aiur_fn_306( let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_306] = [__v_7]; record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -29379,7 +28367,6 @@ fn aiur_fn_306( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_6]; record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -29391,7 +28378,6 @@ fn aiur_fn_306( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_6]; record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29421,10 +28407,9 @@ fn aiur_fn_307( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_307] = [__v_7]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -29432,10 +28417,9 @@ fn aiur_fn_307( let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_307] = [__v_8]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -29447,7 +28431,6 @@ fn aiur_fn_307( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_7]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -29459,7 +28442,6 @@ fn aiur_fn_307( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_7]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -29467,7 +28449,6 @@ fn aiur_fn_307( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_5]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29497,10 +28478,9 @@ fn aiur_fn_308( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_308] = [__v_7]; record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -29509,10 +28489,9 @@ fn aiur_fn_308( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_308] = [__v_8]; record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29542,7 +28521,6 @@ fn aiur_fn_309( 1u64 => { let __ret: [G; OUT_309] = [__v_0]; record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29550,7 +28528,6 @@ fn aiur_fn_309( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_309] = [__v_5]; record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29578,10 +28555,9 @@ fn aiur_fn_310( 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_8]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -29589,10 +28565,9 @@ fn aiur_fn_310( let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_9]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -29600,10 +28575,9 @@ fn aiur_fn_310( let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_9]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -29613,10 +28587,9 @@ fn aiur_fn_310( let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_10]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -29626,10 +28599,9 @@ fn aiur_fn_310( let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_10]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -29639,10 +28611,9 @@ fn aiur_fn_310( let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_10]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -29653,29 +28624,26 @@ fn aiur_fn_310( let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_10]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_8]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_310] = [__v_8]; record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29726,14 +28694,12 @@ fn aiur_fn_311( let __v_22: G = G::from_u64(1); let __ret: [G; OUT_311] = [__v_22]; record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_22]; record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29755,7 +28721,6 @@ fn aiur_fn_311( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_22]; record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -29767,14 +28732,12 @@ fn aiur_fn_311( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_311] = [__v_23]; record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_23]; record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -29821,14 +28784,12 @@ fn aiur_fn_312( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_312] = [__v_8]; record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_8]; record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29843,7 +28804,6 @@ fn aiur_fn_312( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_8]; record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -29854,14 +28814,12 @@ fn aiur_fn_312( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_312] = [__v_9]; record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_9]; record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29900,14 +28858,12 @@ fn aiur_fn_313( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_4]; record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_313] = [__v_4]; record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29919,14 +28875,12 @@ fn aiur_fn_313( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_4]; record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_313] = [__v_4]; record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -29960,28 +28914,24 @@ fn aiur_fn_314( let __v_6: G = (__v_2 + __v_5); let __ret: [G; OUT_314] = [__v_6]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_314] = [__v_5]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_314] = [__v_5]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_314] = [__v_5]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -29993,7 +28943,6 @@ fn aiur_fn_314( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_7]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -30007,7 +28956,6 @@ fn aiur_fn_314( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_8]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -30021,7 +28969,6 @@ fn aiur_fn_314( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_8]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -30029,7 +28976,6 @@ fn aiur_fn_314( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_5]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -30037,7 +28983,6 @@ fn aiur_fn_314( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_5]; record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30074,7 +29019,6 @@ fn aiur_fn_315( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_8]; record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -30096,13 +29040,11 @@ fn aiur_fn_316( 1u64 => { let __ret: [G; OUT_316] = [__v_1]; record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_316] = [__v_0]; record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30128,7 +29070,6 @@ fn aiur_fn_317( let __v_1: G = G::from_u64(0); let __ret: [G; OUT_317] = [__v_1]; record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30136,7 +29077,6 @@ fn aiur_fn_317( let __v_2: G = (__v_0 - __v_1); let __ret: [G; OUT_317] = [__v_2]; record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -30160,13 +29100,11 @@ fn aiur_fn_318( 1u64 => { let __ret: [G; OUT_318] = [__v_0]; record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_318] = [__v_1]; record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30191,7 +29129,6 @@ fn aiur_fn_319( 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_319] = [__v_2]; record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -30222,14 +29159,12 @@ fn aiur_fn_320( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_320] = [__v_8]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; 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_320] = [__v_8]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30241,21 +29176,18 @@ fn aiur_fn_320( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_320] = [__v_7]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_320] = [__v_7]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_320] = [__v_7]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -30266,7 +29198,6 @@ fn aiur_fn_320( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_320] = [__v_8]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -30274,7 +29205,6 @@ fn aiur_fn_320( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_8]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30287,7 +29217,6 @@ fn aiur_fn_320( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_7]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -30295,7 +29224,6 @@ fn aiur_fn_320( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_7]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -30303,7 +29231,6 @@ fn aiur_fn_320( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_7]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -30311,7 +29238,6 @@ fn aiur_fn_320( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_7]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30342,7 +29268,6 @@ fn aiur_fn_321( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_321] = [__v_5]; record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -30354,7 +29279,6 @@ fn aiur_fn_321( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_9]; record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30386,7 +29310,6 @@ fn aiur_fn_322( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_322] = [__v_6]; record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -30397,7 +29320,6 @@ fn aiur_fn_322( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_322] = [__v_7]; record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -30409,7 +29331,6 @@ fn aiur_fn_322( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_11]; record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30444,7 +29365,6 @@ fn aiur_fn_323( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_323] = [__v_4]; record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -30468,7 +29388,6 @@ fn aiur_fn_324( 0u64 => { let __ret: [G; OUT_324] = [__v_2]; record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -30480,7 +29399,6 @@ fn aiur_fn_324( let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_324] = [__v_7]; record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30515,7 +29433,6 @@ fn aiur_fn_325( let __v_7: G = (__v_4 + __v_6); let __ret: [G; OUT_325] = [__v_7]; record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30542,7 +29459,6 @@ fn aiur_fn_326( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_326] = [__v_2]; record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30553,7 +29469,6 @@ fn aiur_fn_326( 0u64 => { let __ret: [G; OUT_326] = [__v_2]; record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -30565,7 +29480,6 @@ fn aiur_fn_326( let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_326] = [__v_7]; record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30593,10 +29507,9 @@ fn aiur_fn_327( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_327] = [__v_4]; record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30607,7 +29520,6 @@ fn aiur_fn_327( 0u64 => { let __ret: [G; OUT_327] = [__v_0]; record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -30617,7 +29529,6 @@ fn aiur_fn_327( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_5]; record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30646,7 +29557,6 @@ fn aiur_fn_328( 0u64 => { let __ret: [G; OUT_328] = [__v_0]; record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30658,7 +29568,6 @@ fn aiur_fn_328( 0u64 => { let __ret: [G; OUT_328] = [__v_0]; record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -30666,7 +29575,6 @@ fn aiur_fn_328( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_5]; record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30702,25 +29610,22 @@ fn aiur_fn_329( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_329] = [__v_7]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_329] = [__v_9]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_329] = [__v_9]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -30730,10 +29635,9 @@ fn aiur_fn_329( let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_329] = [__v_11]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -30745,10 +29649,9 @@ fn aiur_fn_329( let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_329] = [__v_13]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -30760,10 +29663,9 @@ fn aiur_fn_329( let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_329] = [__v_13]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -30771,26 +29673,23 @@ fn aiur_fn_329( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_329] = [__v_7]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_329] = [__v_9]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_329] = [__v_9]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30818,20 +29717,18 @@ fn aiur_fn_330( 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_330] = [__v_6]; record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_330] = [__v_7]; record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30865,10 +29762,9 @@ fn aiur_fn_331( let __v_9: G = (__v_4 + __v_8); let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_331] = [__v_11]; record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -30890,7 +29786,6 @@ fn aiur_fn_332( 0u64 => { let __ret: [G; OUT_332] = [__v_0]; record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30902,7 +29797,6 @@ fn aiur_fn_332( 0u64 => { let __ret: [G; OUT_332] = [__v_0]; record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -30910,7 +29804,6 @@ fn aiur_fn_332( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_332] = [__v_5]; record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30947,17 +29840,15 @@ fn aiur_fn_333( 1u64 => { let __ret: [G; OUT_333] = [__v_0]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_11]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -30968,19 +29859,17 @@ fn aiur_fn_333( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_9]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_9]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -30990,10 +29879,9 @@ fn aiur_fn_333( let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_11]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -31005,10 +29893,9 @@ fn aiur_fn_333( let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_13]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -31020,10 +29907,9 @@ fn aiur_fn_333( let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_13]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -31036,29 +29922,26 @@ fn aiur_fn_333( let __v_11: G = (__v_2 + __v_10); let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_13]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_9]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_9]; record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31089,7 +29972,6 @@ fn aiur_fn_334( 0u64 => { let __ret: [G; OUT_334] = [__v_0]; record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -31097,7 +29979,6 @@ fn aiur_fn_334( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_334] = [__v_5]; record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31131,25 +30012,22 @@ fn aiur_fn_335( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_335] = [__v_7]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -31159,10 +30037,9 @@ fn aiur_fn_335( let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_335] = [__v_11]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -31174,10 +30051,9 @@ fn aiur_fn_335( let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_335] = [__v_13]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -31189,10 +30065,9 @@ fn aiur_fn_335( let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_335] = [__v_13]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -31200,26 +30075,23 @@ fn aiur_fn_335( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_335] = [__v_7]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_335] = [__v_9]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31248,10 +30120,9 @@ fn aiur_fn_336( 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_336] = [__v_6]; record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -31263,7 +30134,6 @@ fn aiur_fn_336( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_336] = [__v_6]; record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31271,10 +30141,9 @@ fn aiur_fn_336( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_336] = [__v_9]; record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31310,10 +30179,9 @@ fn aiur_fn_337( let __v_9: G = (__v_4 + __v_8); let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_337] = [__v_11]; record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -31339,7 +30207,6 @@ fn aiur_fn_338( 0u64 => { let __ret: [G; OUT_338] = [__v_0]; record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -31347,7 +30214,6 @@ fn aiur_fn_338( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_5]; record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31384,17 +30250,15 @@ fn aiur_fn_339( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_339] = [__v_8]; record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_339] = [__v_9]; record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31428,25 +30292,22 @@ fn aiur_fn_340( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_340] = [__v_7]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_340] = [__v_9]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_340] = [__v_9]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -31456,10 +30317,9 @@ fn aiur_fn_340( let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_340] = [__v_11]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -31471,10 +30331,9 @@ fn aiur_fn_340( let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_340] = [__v_13]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -31486,10 +30345,9 @@ fn aiur_fn_340( let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_340] = [__v_13]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -31497,26 +30355,23 @@ fn aiur_fn_340( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_340] = [__v_7]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_340] = [__v_9]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_340] = [__v_9]; record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31550,10 +30405,9 @@ fn aiur_fn_341( let __v_9: G = (__v_4 + __v_8); let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_341] = [__v_11]; record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -31585,20 +30439,18 @@ fn aiur_fn_342( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __ret: [G; OUT_342] = [__v_12, __v_13, __v_14]; record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_342] = [__v_0, __v_2, __v_1]; record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31609,7 +30461,6 @@ fn aiur_fn_342( _ => { let __ret: [G; OUT_342] = [__v_0, __v_2, __v_1]; record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31631,7 +30482,7 @@ fn aiur_fn_343( let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; @@ -31644,7 +30495,6 @@ fn aiur_fn_343( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_10]; record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -31658,7 +30508,6 @@ fn aiur_fn_343( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_14]; record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31669,7 +30518,6 @@ fn aiur_fn_343( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_12]; record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31705,7 +30553,6 @@ fn aiur_fn_344( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_10]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -31713,7 +30560,6 @@ fn aiur_fn_344( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_7]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -31721,7 +30567,6 @@ fn aiur_fn_344( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_7]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -31732,7 +30577,6 @@ fn aiur_fn_344( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_9]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -31740,7 +30584,6 @@ fn aiur_fn_344( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_7]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31748,7 +30591,6 @@ fn aiur_fn_344( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_7]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31786,7 +30628,6 @@ fn aiur_fn_345( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_11]; record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -31821,29 +30662,26 @@ fn aiur_fn_345( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_30]; record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_30]; record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_17]; record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -31894,10 +30732,9 @@ fn aiur_fn_346( let __v_29: G = G::from_u64(86); let __v_30: G = G::from_u64(91); let __v_31: G = G::from_u64(151); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_346] = [__v_32]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -31944,10 +30781,9 @@ fn aiur_fn_347( let __v_29: G = G::from_u64(179); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(25); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_347] = [__v_32]; record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -31994,10 +30830,9 @@ fn aiur_fn_348( let __v_29: G = G::from_u64(242); let __v_30: G = G::from_u64(182); let __v_31: G = G::from_u64(49); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_348] = [__v_32]; record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -32044,10 +30879,9 @@ fn aiur_fn_349( let __v_29: G = G::from_u64(125); let __v_30: G = G::from_u64(236); let __v_31: G = G::from_u64(246); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_349] = [__v_32]; record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -32094,10 +30928,9 @@ fn aiur_fn_350( let __v_29: G = G::from_u64(139); let __v_30: G = G::from_u64(123); let __v_31: G = G::from_u64(208); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_350] = [__v_32]; record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -32144,10 +30977,9 @@ fn aiur_fn_351( let __v_29: G = G::from_u64(176); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(22); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_351] = [__v_32]; record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -32176,10 +31008,9 @@ fn aiur_fn_352( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_6, __v_10]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32202,10 +31033,9 @@ fn aiur_fn_352( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_12, __v_16]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32219,10 +31049,9 @@ fn aiur_fn_352( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_15, __v_19]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32256,10 +31085,10 @@ fn aiur_fn_352( match __v_29.as_canonical_u64() { 4u64 => { let __v_33: G = G::from_u64(8); - let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_35: G = G::from_u64(4); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; let __v_39: G = __loaded[1]; @@ -32268,39 +31097,39 @@ fn aiur_fn_352( match __v_38.as_canonical_u64() { 4u64 => { let __v_42: G = G::from_u64(8); - let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(4); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_47: G = G::from_u64(2); let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(4); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_57: G = G::from_u64(2); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_63: G = G::from_u64(3); let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(3); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_69: G = G::from_u64(3); let __v_70: G = G::from_u64(0); - let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_72: G = G::from_u64(3); let __v_73: G = G::from_u64(0); - let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_75: G = G::from_u64(5); let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; @@ -32309,7 +31138,6 @@ fn aiur_fn_352( let __v_78: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_77, __v_78]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32317,10 +31145,9 @@ fn aiur_fn_352( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_42, __v_46]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32330,10 +31157,9 @@ fn aiur_fn_352( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_33, __v_37]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32343,10 +31169,9 @@ fn aiur_fn_352( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_29, __v_33]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32360,10 +31185,9 @@ fn aiur_fn_352( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_10, __v_14]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32373,10 +31197,9 @@ fn aiur_fn_352( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_352] = [__v_6, __v_10]; record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32407,7 +31230,6 @@ fn aiur_fn_353( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_353] = [__v_5]; record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32416,15 +31238,14 @@ fn aiur_fn_353( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_353] = [__v_15]; record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32451,10 +31272,9 @@ fn aiur_fn_354( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_354] = [__v_7]; record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -32463,10 +31283,9 @@ fn aiur_fn_354( let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_354] = [__v_8]; record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32496,7 +31315,6 @@ fn aiur_fn_355( let __v_5: G = __r_arr[1]; let __ret: [G; OUT_355] = [__v_4, __v_5]; record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -32523,7 +31341,6 @@ fn aiur_fn_356( 1u64 => { let __ret: [G; OUT_356] = [__v_2]; record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -32535,7 +31352,6 @@ fn aiur_fn_356( 1u64 => { let __ret: [G; OUT_356] = [__v_2]; record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -32550,11 +31366,10 @@ fn aiur_fn_356( let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_356] = [__v_17]; record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32587,7 +31402,6 @@ fn aiur_fn_357( let __v_2: G = G::from_u64(1); let __ret: [G; OUT_357] = [__v_2]; record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32598,7 +31412,6 @@ fn aiur_fn_357( let __v_3: G = G::from_u64(2); let __ret: [G; OUT_357] = [__v_3]; record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32609,7 +31422,6 @@ fn aiur_fn_357( let __v_4: G = G::from_u64(3); let __ret: [G; OUT_357] = [__v_4]; record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32620,7 +31432,6 @@ fn aiur_fn_357( let __v_5: G = G::from_u64(4); let __ret: [G; OUT_357] = [__v_5]; record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32631,14 +31442,12 @@ fn aiur_fn_357( let __v_6: G = G::from_u64(5); let __ret: [G; OUT_357] = [__v_6]; record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_357] = [__v_6]; record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32676,7 +31485,6 @@ fn aiur_fn_358( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_358] = [__v_5, __v_6]; record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -32687,7 +31495,6 @@ fn aiur_fn_358( let __v_7: G = __r_arr[1]; let __ret: [G; OUT_358] = [__v_6, __v_7]; record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -32696,7 +31503,6 @@ fn aiur_fn_358( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_358] = [__v_5, __v_6]; record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -32705,7 +31511,6 @@ fn aiur_fn_358( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_358] = [__v_5, __v_6]; record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -32714,7 +31519,6 @@ fn aiur_fn_358( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_358] = [__v_5, __v_6]; record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32722,10 +31526,9 @@ fn aiur_fn_358( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_358] = [__v_5, __v_9]; record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32756,7 +31559,6 @@ fn aiur_fn_359( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_359] = [__v_5, __v_6]; record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32771,7 +31573,6 @@ fn aiur_fn_359( let __v_8: G = __r_arr[1]; let __ret: [G; OUT_359] = [__v_7, __v_8]; record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32779,10 +31580,9 @@ fn aiur_fn_359( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_359] = [__v_7, __v_11]; record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32813,10 +31613,9 @@ fn aiur_fn_360( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_360] = [__v_5, __v_9]; record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32837,12 +31636,11 @@ fn aiur_fn_360( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_360] = [__v_13, __v_17]; record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32850,10 +31648,9 @@ fn aiur_fn_360( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_360] = [__v_11, __v_15]; record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32884,10 +31681,9 @@ fn aiur_fn_361( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_361] = [__v_5, __v_9]; record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32908,12 +31704,11 @@ fn aiur_fn_361( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_13, __v_17]; record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32921,10 +31716,9 @@ fn aiur_fn_361( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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, __v_15]; record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32975,7 +31769,6 @@ fn aiur_fn_362( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_14, __v_16]; record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -32983,10 +31776,9 @@ fn aiur_fn_362( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_362] = [__v_14, __v_18]; record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -32996,10 +31788,9 @@ fn aiur_fn_362( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_362] = [__v_11, __v_15]; record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33009,10 +31800,9 @@ fn aiur_fn_362( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_362] = [__v_9, __v_13]; record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33043,13 +31833,11 @@ fn aiur_fn_363( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_7]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_363] = [__v_6]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33079,7 +31867,6 @@ fn aiur_fn_363( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_22]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33089,7 +31876,6 @@ fn aiur_fn_363( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_23]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33099,7 +31885,6 @@ fn aiur_fn_363( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_20]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -33112,7 +31897,6 @@ fn aiur_fn_363( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_22]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33120,7 +31904,6 @@ fn aiur_fn_363( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_22]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33137,7 +31920,6 @@ fn aiur_fn_363( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_23]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -33153,7 +31935,6 @@ fn aiur_fn_363( let __v_28: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_28]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33166,13 +31947,11 @@ fn aiur_fn_363( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_25]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_363] = [__v_22]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33184,7 +31963,6 @@ fn aiur_fn_363( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_23]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33194,7 +31972,6 @@ fn aiur_fn_363( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_20]; record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33233,17 +32010,16 @@ fn aiur_fn_364( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_364] = [__v_10, __v_14]; record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); - let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); @@ -33251,7 +32027,6 @@ fn aiur_fn_364( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_14, __v_15]; record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33261,10 +32036,9 @@ fn aiur_fn_364( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_364] = [__v_8, __v_12]; record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33300,7 +32074,6 @@ fn aiur_fn_365( let __v_12: G = __r_arr[4]; let __ret: [G; OUT_365] = [__v_8, __v_9, __v_10, __v_11, __v_12]; record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -33320,7 +32093,6 @@ fn aiur_fn_365( let __v_14: G = (__v_13 - __v_7); let __ret: [G; OUT_365] = [__v_11, __v_1, __v_3, __v_4, __v_14]; record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33358,12 +32130,11 @@ fn aiur_fn_365( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __ret: [G; OUT_365] = [__v_11, __v_12, __v_45, __v_46, __v_47]; record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33403,12 +32174,11 @@ fn aiur_fn_365( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __ret: [G; OUT_365] = [__v_10, __v_11, __v_44, __v_45, __v_46]; record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33448,12 +32218,11 @@ fn aiur_fn_365( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_365] = [__v_6, __v_7, __v_40, __v_41, __v_42]; record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33489,12 +32258,11 @@ fn aiur_fn_366( let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_366] = [__v_12]; record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33505,21 +32273,20 @@ fn aiur_fn_366( let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(2); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_366] = [__v_21]; record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33527,7 +32294,6 @@ fn aiur_fn_366( _ => { let __ret: [G; OUT_366] = [__v_0]; record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33535,7 +32301,6 @@ fn aiur_fn_366( _ => { let __ret: [G; OUT_366] = [__v_0]; record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33583,7 +32348,6 @@ fn aiur_fn_367( 0u64 => { let __ret: [G; OUT_367] = [__v_7]; record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33605,7 +32369,6 @@ fn aiur_fn_367( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_29]; record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33615,7 +32378,6 @@ fn aiur_fn_367( _ => { let __ret: [G; OUT_367] = [__v_7]; record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33658,7 +32420,6 @@ fn aiur_fn_368( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_368] = [__v_14]; record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33683,7 +32444,7 @@ fn aiur_fn_368( let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; @@ -33694,14 +32455,12 @@ fn aiur_fn_368( let __v_34: G = __r_arr[0]; let __ret: [G; OUT_368] = [__v_34]; record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_368] = [__v_27]; record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33712,7 +32471,6 @@ fn aiur_fn_368( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_368] = [__v_13]; record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33741,15 +32499,14 @@ fn aiur_fn_369( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_369] = [__v_13]; record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -33786,10 +32543,9 @@ fn aiur_fn_370( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_370] = [__v_15, __v_19]; record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33801,7 +32557,6 @@ fn aiur_fn_370( let __v_17: G = G::from_u64(1); let __ret: [G; OUT_370] = [__v_17, __v_16]; record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33841,7 +32596,6 @@ fn aiur_fn_370( let __v_33: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_32, __v_33]; record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -33869,7 +32623,6 @@ fn aiur_fn_370( let __v_44: G = G::from_u64(1); let __ret: [G; OUT_370] = [__v_44, __v_43]; record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33885,7 +32638,6 @@ fn aiur_fn_370( let __v_28: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_27, __v_28]; record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -33939,7 +32691,6 @@ fn aiur_fn_371( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_371] = [__v_20, __v_13, __v_21, __v_2]; record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -33977,13 +32728,12 @@ fn aiur_fn_371( let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); let __v_53: G = G::from_u64(0); - let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); - let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_371] = [__v_20, __v_21, __v_54, __v_57]; record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34023,13 +32773,12 @@ fn aiur_fn_371( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_371] = [__v_7, __v_8, __v_41, __v_44]; record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34061,10 +32810,9 @@ fn aiur_fn_372( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_372] = [__v_7, __v_8, __v_12]; record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -34076,7 +32824,6 @@ fn aiur_fn_372( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_372] = [__v_8, __v_4, __v_5]; record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34086,7 +32833,6 @@ fn aiur_fn_372( let __v_10: G = __r_arr[2]; let __ret: [G; OUT_372] = [__v_8, __v_9, __v_10]; record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34131,10 +32877,9 @@ fn aiur_fn_373( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_14, __v_18]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -34150,10 +32895,9 @@ fn aiur_fn_373( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_19, __v_23]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -34171,10 +32915,9 @@ fn aiur_fn_373( let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_24, __v_28]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34209,10 +32952,9 @@ fn aiur_fn_373( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_40, __v_44]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34228,10 +32970,9 @@ fn aiur_fn_373( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_43, __v_47]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34255,7 +32996,6 @@ fn aiur_fn_373( let __v_54: G = __r_arr[0]; let __ret: [G; OUT_373] = [__v_53, __v_54]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34267,10 +33007,9 @@ fn aiur_fn_373( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_39, __v_43]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34280,10 +33019,9 @@ fn aiur_fn_373( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_39, __v_43]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34293,10 +33031,9 @@ fn aiur_fn_373( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_373] = [__v_37, __v_41]; record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34351,7 +33088,6 @@ fn aiur_fn_374( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_374] = [__v_12, __v_9]; record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34388,10 +33124,9 @@ fn aiur_fn_374( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_374] = [__v_12, __v_45]; record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34430,10 +33165,9 @@ fn aiur_fn_374( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_374] = [__v_6, __v_39]; record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34453,7 +33187,6 @@ fn aiur_fn_374( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_374] = [__v_8, __v_9]; record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34490,10 +33223,9 @@ fn aiur_fn_374( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_374] = [__v_6, __v_39]; record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34522,22 +33254,20 @@ fn aiur_fn_375( 0u64 => { let __ret: [G; OUT_375] = [__v_0]; record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(8); - let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_13]; record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34579,14 +33309,12 @@ fn aiur_fn_376( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_376] = [__v_16]; record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_376] = [__v_14]; record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34662,18 +33390,16 @@ fn aiur_fn_377( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_377] = [__v_50]; record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_377] = [__v_54]; record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34704,7 +33430,6 @@ fn aiur_fn_378( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_378] = [__v_7]; record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34734,7 +33459,6 @@ fn aiur_fn_378( let __v_22: G = G::from_u64(1); let __ret: [G; OUT_378] = [__v_22]; record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34744,7 +33468,6 @@ fn aiur_fn_378( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_378] = [__v_24]; record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34753,7 +33476,6 @@ fn aiur_fn_378( let __v_20: G = G::from_u64(1); let __ret: [G; OUT_378] = [__v_20]; record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34778,7 +33500,6 @@ fn aiur_fn_379( 0u64 => { let __ret: [G; OUT_379] = [__v_0]; record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34795,13 +33516,11 @@ fn aiur_fn_379( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_379] = [__v_8]; record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_379] = [__v_0]; record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34836,7 +33555,6 @@ fn aiur_fn_380( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_380] = [__v_7]; record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34844,7 +33562,6 @@ fn aiur_fn_380( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_380] = [__v_7]; record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34853,7 +33570,6 @@ fn aiur_fn_380( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_380] = [__v_6]; record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34883,7 +33599,6 @@ fn aiur_fn_381( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_6]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -34894,7 +33609,6 @@ fn aiur_fn_381( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34902,7 +33616,6 @@ fn aiur_fn_381( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34915,7 +33628,6 @@ fn aiur_fn_381( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34923,7 +33635,6 @@ fn aiur_fn_381( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34936,7 +33647,6 @@ fn aiur_fn_381( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34944,7 +33654,6 @@ fn aiur_fn_381( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34957,7 +33666,6 @@ fn aiur_fn_381( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_381] = [__v_7]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34968,7 +33676,6 @@ fn aiur_fn_381( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_381] = [__v_8]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -34976,7 +33683,6 @@ fn aiur_fn_381( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_8]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -34988,14 +33694,12 @@ fn aiur_fn_381( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_6]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_381] = [__v_6]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35023,7 +33727,6 @@ fn aiur_fn_382( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_382] = [__v_5]; record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -35034,7 +33737,6 @@ fn aiur_fn_382( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_382] = [__v_6]; record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35042,7 +33744,6 @@ fn aiur_fn_382( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_382] = [__v_6]; record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35075,31 +33776,26 @@ fn aiur_fn_383( 1u64 => { let __ret: [G; OUT_383] = [__v_0]; record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_383] = [__v_0]; record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_383] = [__v_0]; record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_383] = [__v_0]; record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_383] = [__v_0]; record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35111,7 +33807,6 @@ fn aiur_fn_383( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_383] = [__v_8]; record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35132,12 +33827,11 @@ fn aiur_fn_384( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_384] = [__v_5]; record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -35163,31 +33857,26 @@ fn aiur_fn_385( 1u64 => { let __ret: [G; OUT_385] = [__v_0]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_385] = [__v_0]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_385] = [__v_0]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_385] = [__v_0]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_385] = [__v_0]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35199,7 +33888,6 @@ fn aiur_fn_385( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_8]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35220,12 +33908,11 @@ fn aiur_fn_386( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_386] = [__v_5]; record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -35259,7 +33946,6 @@ fn aiur_fn_387( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_10]; record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -35267,7 +33953,6 @@ fn aiur_fn_387( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_7]; record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -35275,7 +33960,6 @@ fn aiur_fn_387( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_7]; record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -35286,7 +33970,6 @@ fn aiur_fn_387( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_9]; record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -35294,7 +33977,6 @@ fn aiur_fn_387( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_7]; record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35302,7 +33984,6 @@ fn aiur_fn_387( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_7]; record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35324,7 +34005,7 @@ fn aiur_fn_388( let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; @@ -35337,7 +34018,6 @@ fn aiur_fn_388( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_10]; record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -35351,7 +34031,6 @@ fn aiur_fn_388( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_14]; record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35362,7 +34041,6 @@ fn aiur_fn_388( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_12]; record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35400,7 +34078,6 @@ fn aiur_fn_389( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_11]; record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35435,29 +34112,26 @@ fn aiur_fn_389( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_30]; record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_30]; record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_17]; record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35490,13 +34164,11 @@ fn aiur_fn_390( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_7]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_390] = [__v_6]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35526,7 +34198,6 @@ fn aiur_fn_390( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_22]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35534,7 +34205,6 @@ fn aiur_fn_390( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_22]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35549,7 +34219,6 @@ fn aiur_fn_390( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_22]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35557,7 +34226,6 @@ fn aiur_fn_390( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_22]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35574,7 +34242,6 @@ fn aiur_fn_390( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_23]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35582,7 +34249,6 @@ fn aiur_fn_390( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_23]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35592,7 +34258,6 @@ fn aiur_fn_390( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_20]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -35622,7 +34287,6 @@ fn aiur_fn_391( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_391] = [__v_6]; record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -35653,49 +34317,41 @@ fn aiur_fn_392( 0u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_392] = [__v_1]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35731,49 +34387,41 @@ fn aiur_fn_393( 0u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_393] = [__v_2]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35803,7 +34451,6 @@ fn aiur_fn_394( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_4]; record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -35831,21 +34478,19 @@ fn aiur_fn_395( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_395] = [__v_6]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_395] = [__v_12]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -35877,7 +34522,6 @@ fn aiur_fn_395( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_395] = [__v_22]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -35895,7 +34539,6 @@ fn aiur_fn_395( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_395] = [__v_12]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35913,7 +34556,6 @@ fn aiur_fn_395( let __v_17: G = __r_arr[0]; let __ret: [G; OUT_395] = [__v_17]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -35925,32 +34567,30 @@ fn aiur_fn_395( }, 4u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_395] = [__v_13]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -35961,7 +34601,6 @@ fn aiur_fn_395( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_395] = [__v_8]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -35972,12 +34611,11 @@ fn aiur_fn_395( let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_395] = [__v_12]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -35986,12 +34624,11 @@ fn aiur_fn_395( let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_395] = [__v_12]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36065,7 +34702,6 @@ fn aiur_fn_395( let __v_45: G = __r_arr[0]; let __ret: [G; OUT_395] = [__v_45]; record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36113,7 +34749,6 @@ fn aiur_fn_396( 1u64 => { let __ret: [G; OUT_396] = [__v_4]; record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36128,7 +34763,6 @@ fn aiur_fn_396( 1u64 => { let __ret: [G; OUT_396] = [__v_9]; record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36157,7 +34791,6 @@ fn aiur_fn_397( 0u64 => { let __ret: [G; OUT_397] = [__v_0]; record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36183,7 +34816,6 @@ fn aiur_fn_397( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_397] = [__v_14]; record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36227,12 +34859,11 @@ fn aiur_fn_398( 0u64 => { let __ret: [G; OUT_398] = [__v_6]; record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); - let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -36242,7 +34873,6 @@ fn aiur_fn_398( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_398] = [__v_16]; record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36281,14 +34911,12 @@ fn aiur_fn_399( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_399] = [__v_8]; record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_399] = [__v_8]; record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36303,7 +34931,6 @@ fn aiur_fn_399( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_399] = [__v_8]; record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -36314,7 +34941,6 @@ fn aiur_fn_399( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_399] = [__v_9]; record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36322,7 +34948,6 @@ fn aiur_fn_399( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_399] = [__v_9]; record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36358,7 +34983,6 @@ fn aiur_fn_400( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_400] = [__v_4]; record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36374,7 +34998,6 @@ fn aiur_fn_400( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_400] = [__v_8]; record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36401,7 +35024,6 @@ fn aiur_fn_401( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_4]; record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36409,7 +35031,6 @@ fn aiur_fn_401( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_4]; record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36436,7 +35057,6 @@ fn aiur_fn_402( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_4]; record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36444,7 +35064,6 @@ fn aiur_fn_402( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_402] = [__v_4]; record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36494,7 +35113,6 @@ fn aiur_fn_403( let __v_17: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_17]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36509,14 +35127,12 @@ fn aiur_fn_403( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_403] = [__v_20]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_20]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36527,7 +35143,6 @@ fn aiur_fn_403( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_16]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36536,7 +35151,6 @@ fn aiur_fn_403( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_15]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36545,7 +35159,6 @@ fn aiur_fn_403( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_11]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36580,14 +35193,12 @@ fn aiur_fn_404( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36602,7 +35213,6 @@ fn aiur_fn_404( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -36613,7 +35223,6 @@ fn aiur_fn_404( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_404] = [__v_10]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36621,7 +35230,6 @@ fn aiur_fn_404( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_10]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36662,14 +35270,12 @@ fn aiur_fn_405( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_5]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_405] = [__v_5]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36681,14 +35287,12 @@ fn aiur_fn_405( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_6]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_405] = [__v_5]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36718,22 +35322,20 @@ fn aiur_fn_406( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_406] = [__v_5, __v_9, __v_3]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_5, __v_0, __v_8]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36761,17 +35363,15 @@ fn aiur_fn_406( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_406] = [__v_14, __v_12, __v_15]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_11, __v_0, __v_14]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36810,14 +35410,12 @@ fn aiur_fn_406( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_406] = [__v_22, __v_20, __v_23]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_406] = [__v_22, __v_7, __v_17]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36826,10 +35424,9 @@ fn aiur_fn_406( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_19, __v_0, __v_22]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36838,10 +35435,9 @@ fn aiur_fn_406( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_19, __v_0, __v_22]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36850,10 +35446,9 @@ fn aiur_fn_406( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_15, __v_0, __v_18]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36862,10 +35457,9 @@ fn aiur_fn_406( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_13, __v_0, __v_16]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36874,10 +35468,9 @@ fn aiur_fn_406( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_9, __v_0, __v_12]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36886,10 +35479,9 @@ fn aiur_fn_406( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_406] = [__v_5, __v_0, __v_8]; record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36920,7 +35512,6 @@ fn aiur_fn_407( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_407] = [__v_6, __v_7]; record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36939,7 +35530,6 @@ fn aiur_fn_407( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_407] = [__v_13, __v_14]; record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36951,7 +35541,6 @@ fn aiur_fn_407( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_407] = [__v_14, __v_15]; record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36960,7 +35549,6 @@ fn aiur_fn_407( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_14, __v_15]; record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -36991,7 +35579,6 @@ fn aiur_fn_408( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_408] = [__v_4]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -36999,7 +35586,6 @@ fn aiur_fn_408( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_4]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37036,14 +35622,12 @@ fn aiur_fn_409( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_409] = [__v_9]; record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_409] = [__v_7]; record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37052,7 +35636,6 @@ fn aiur_fn_409( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_409] = [__v_7]; record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37079,7 +35662,6 @@ fn aiur_fn_410( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_410] = [__v_4]; record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37087,7 +35669,6 @@ fn aiur_fn_410( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_410] = [__v_4]; record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37117,7 +35698,6 @@ fn aiur_fn_411( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_411] = [__v_6]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37128,7 +35708,6 @@ fn aiur_fn_411( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_411] = [__v_7]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37139,7 +35718,6 @@ fn aiur_fn_411( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_411] = [__v_8]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37147,7 +35725,6 @@ fn aiur_fn_411( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_8]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37189,14 +35766,12 @@ fn aiur_fn_412( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_11]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_11]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37214,19 +35789,17 @@ fn aiur_fn_412( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_14]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_12]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37235,7 +35808,6 @@ fn aiur_fn_412( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_11]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37253,19 +35825,17 @@ fn aiur_fn_412( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_14]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_12]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37274,7 +35844,6 @@ fn aiur_fn_412( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_11]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37283,7 +35852,6 @@ fn aiur_fn_412( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_7]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37313,7 +35881,6 @@ fn aiur_fn_413( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_6]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37324,7 +35891,6 @@ fn aiur_fn_413( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_7]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37335,7 +35901,6 @@ fn aiur_fn_413( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_8]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37346,7 +35911,6 @@ fn aiur_fn_413( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_9]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37357,7 +35921,6 @@ fn aiur_fn_413( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_10]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37368,7 +35931,6 @@ fn aiur_fn_413( 1u64 => { let __ret: [G; OUT_413] = [__v_11]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37380,7 +35942,6 @@ fn aiur_fn_413( let __v_14: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_14]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37391,7 +35952,6 @@ fn aiur_fn_413( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_15]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37399,7 +35959,6 @@ fn aiur_fn_413( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_15]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37493,7 +36052,6 @@ fn aiur_fn_414( let __v_43: G = G::from_u64(0); let __ret: [G; OUT_414] = [__v_43]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37506,7 +36064,6 @@ fn aiur_fn_414( let __v_45: G = G::from_u64(0); let __ret: [G; OUT_414] = [__v_45]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37521,7 +36078,6 @@ fn aiur_fn_414( let __v_48: G = G::from_u64(0); let __ret: [G; OUT_414] = [__v_48]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37530,7 +36086,6 @@ fn aiur_fn_414( let __v_49: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_49]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37543,7 +36098,6 @@ fn aiur_fn_414( let __v_38: G = G::from_u64(0); let __ret: [G; OUT_414] = [__v_38]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37552,7 +36106,6 @@ fn aiur_fn_414( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_414] = [__v_25]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37561,7 +36114,6 @@ fn aiur_fn_414( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_414] = [__v_22]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37570,7 +36122,6 @@ fn aiur_fn_414( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_414] = [__v_9]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37600,12 +36151,11 @@ fn aiur_fn_415( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_415] = [__v_8]; record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = (__v_1 + __v_5); let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -37616,7 +36166,6 @@ fn aiur_fn_415( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_415] = [__v_13]; record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37626,7 +36175,6 @@ fn aiur_fn_415( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_415] = [__v_15]; record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37660,23 +36208,22 @@ fn aiur_fn_416( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_416] = [__v_25]; record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -37711,7 +36258,6 @@ fn aiur_fn_417( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_417] = [__v_11]; record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37719,7 +36265,6 @@ fn aiur_fn_417( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_11]; record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37736,14 +36281,12 @@ fn aiur_fn_417( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_11]; record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_417] = [__v_11]; record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37776,7 +36319,6 @@ fn aiur_fn_418( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_418] = [__v_6]; record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37786,7 +36328,6 @@ fn aiur_fn_418( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_7]; record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37860,14 +36401,12 @@ fn aiur_fn_419( let __v_36: G = G::from_u64(1); let __ret: [G; OUT_419] = [__v_36]; record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_36]; record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37876,7 +36415,6 @@ fn aiur_fn_419( let __v_36: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_36]; record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37885,7 +36423,6 @@ fn aiur_fn_419( let __v_22: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_22]; record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37894,7 +36431,6 @@ fn aiur_fn_419( let __v_20: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_20]; record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37903,7 +36439,6 @@ fn aiur_fn_419( let __v_20: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_20]; record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37912,7 +36447,6 @@ fn aiur_fn_419( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_7]; record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37941,7 +36475,6 @@ fn aiur_fn_420( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_420] = [__v_5]; record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -37951,7 +36484,6 @@ fn aiur_fn_420( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_420] = [__v_6]; record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -37990,7 +36522,6 @@ fn aiur_fn_421( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_421] = [__v_11]; record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38001,17 +36532,16 @@ fn aiur_fn_421( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_421] = [__v_23]; record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38020,7 +36550,6 @@ fn aiur_fn_421( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_421] = [__v_10]; record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38059,14 +36588,12 @@ fn aiur_fn_422( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_422] = [__v_11]; record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_422] = [__v_11]; record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38075,7 +36602,6 @@ fn aiur_fn_422( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_422] = [__v_8]; record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38099,7 +36625,6 @@ fn aiur_fn_423( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_3]; record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -38137,14 +36662,12 @@ fn aiur_fn_424( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38153,7 +36676,6 @@ fn aiur_fn_424( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38170,14 +36692,12 @@ fn aiur_fn_424( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38198,7 +36718,6 @@ fn aiur_fn_424( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38206,7 +36725,6 @@ fn aiur_fn_424( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38216,7 +36734,6 @@ fn aiur_fn_424( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38237,7 +36754,6 @@ fn aiur_fn_424( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38249,14 +36765,12 @@ fn aiur_fn_424( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_13]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_424] = [__v_13]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38268,7 +36782,6 @@ fn aiur_fn_424( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38288,17 +36801,15 @@ fn aiur_fn_424( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_14]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38308,7 +36819,6 @@ fn aiur_fn_424( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38328,17 +36838,15 @@ fn aiur_fn_424( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_14]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38347,7 +36855,6 @@ fn aiur_fn_424( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38356,7 +36863,6 @@ fn aiur_fn_424( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_7]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -38371,7 +36877,6 @@ fn aiur_fn_424( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38383,7 +36888,6 @@ fn aiur_fn_424( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_13]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38391,7 +36895,6 @@ fn aiur_fn_424( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_13]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38417,14 +36920,12 @@ fn aiur_fn_424( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_13]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_13]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38433,7 +36934,6 @@ fn aiur_fn_424( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_12]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38442,7 +36942,6 @@ fn aiur_fn_424( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_11]; record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38473,7 +36972,6 @@ fn aiur_fn_425( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_425] = [__v_4]; record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38483,7 +36981,6 @@ fn aiur_fn_425( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_425] = [__v_5]; record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38504,7 +37001,6 @@ fn aiur_fn_425( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_425] = [__v_10]; record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38512,7 +37008,6 @@ fn aiur_fn_425( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_10]; record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38522,7 +37017,6 @@ fn aiur_fn_425( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_9]; record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38534,7 +37028,6 @@ fn aiur_fn_425( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_9]; record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38542,7 +37035,6 @@ fn aiur_fn_425( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_9]; record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38581,14 +37073,12 @@ fn aiur_fn_426( 1u64 => { let __ret: [G; OUT_426] = [__v_5]; record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_426] = [__v_12]; record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38652,7 +37142,6 @@ fn aiur_fn_427( let __v_34: G = G::from_u64(0); let __ret: [G; OUT_427] = [__v_34]; record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38660,7 +37149,6 @@ fn aiur_fn_427( let __v_34: G = __r_arr[0]; let __ret: [G; OUT_427] = [__v_34]; record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38672,7 +37160,6 @@ fn aiur_fn_427( let __v_34: G = __r_arr[0]; let __ret: [G; OUT_427] = [__v_34]; record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38687,7 +37174,6 @@ fn aiur_fn_427( let __v_37: G = __r_arr[0]; let __ret: [G; OUT_427] = [__v_37]; record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38698,7 +37184,6 @@ fn aiur_fn_427( let __v_38: G = __r_arr[0]; let __ret: [G; OUT_427] = [__v_38]; record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38706,7 +37191,6 @@ fn aiur_fn_427( let __v_38: G = __r_arr[0]; let __ret: [G; OUT_427] = [__v_38]; record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38746,14 +37230,12 @@ fn aiur_fn_428( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_9]; record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_428] = [__v_6]; record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38787,14 +37269,12 @@ fn aiur_fn_429( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_9]; record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_429] = [__v_6]; record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38835,14 +37315,12 @@ fn aiur_fn_430( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_12]; record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_430] = [__v_8]; record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38851,7 +37329,6 @@ fn aiur_fn_430( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_430] = [__v_6]; record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38895,7 +37372,6 @@ fn aiur_fn_431( let __v_19: G = G::from_u64(0); let __ret: [G; OUT_431] = [__v_19]; record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38913,7 +37389,6 @@ fn aiur_fn_431( let __v_23: G = G::from_u64(1); let __ret: [G; OUT_431] = [__v_23]; record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38923,7 +37398,6 @@ fn aiur_fn_431( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_25]; record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38941,7 +37415,6 @@ fn aiur_fn_431( let __v_24: G = G::from_u64(1); let __ret: [G; OUT_431] = [__v_24]; record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -38951,7 +37424,6 @@ fn aiur_fn_431( let __v_26: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_26]; record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -38960,7 +37432,6 @@ fn aiur_fn_431( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_431] = [__v_23]; record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39008,7 +37479,6 @@ fn aiur_fn_432( let __v_19: G = G::from_u64(0); let __ret: [G; OUT_432] = [__v_19]; record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39026,7 +37496,6 @@ fn aiur_fn_432( let __v_23: G = G::from_u64(1); let __ret: [G; OUT_432] = [__v_23]; record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39036,7 +37505,6 @@ fn aiur_fn_432( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_25]; record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39054,7 +37522,6 @@ fn aiur_fn_432( let __v_24: G = G::from_u64(1); let __ret: [G; OUT_432] = [__v_24]; record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39064,7 +37531,6 @@ fn aiur_fn_432( let __v_26: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_26]; record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39073,7 +37539,6 @@ fn aiur_fn_432( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_432] = [__v_23]; record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39119,7 +37584,6 @@ fn aiur_fn_433( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_433] = [__v_11]; record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39129,7 +37593,6 @@ fn aiur_fn_433( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_13]; record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39142,7 +37605,6 @@ fn aiur_fn_433( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_433] = [__v_10]; record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39152,7 +37614,6 @@ fn aiur_fn_433( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_12]; record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39171,7 +37632,6 @@ fn aiur_fn_433( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_433] = [__v_10]; record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39181,7 +37641,6 @@ fn aiur_fn_433( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_12]; record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39190,7 +37649,6 @@ fn aiur_fn_433( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_433] = [__v_8]; record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39226,21 +37684,18 @@ fn aiur_fn_434( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_434] = [__v_12]; record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_434] = [__v_12]; record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_434] = [__v_12]; record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39274,20 +37729,18 @@ fn aiur_fn_435( match __v_7.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(8); - let __v_10: G = { let __values: [G; 4] = [__v_9, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_11, __v_12]; record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_435] = [__v_9, __v_0]; record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39296,7 +37749,6 @@ fn aiur_fn_435( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_435] = [__v_7, __v_0]; record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39348,7 +37800,6 @@ fn aiur_fn_436( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_21, __v_22]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -39359,14 +37810,12 @@ fn aiur_fn_436( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_21, __v_22]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_436] = [__v_20, __v_0]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39375,7 +37824,6 @@ fn aiur_fn_436( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_436] = [__v_7, __v_0]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39406,7 +37854,6 @@ fn aiur_fn_437( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_437] = [__v_7]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39415,7 +37862,6 @@ fn aiur_fn_437( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_437] = [__v_7]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39463,7 +37909,6 @@ fn aiur_fn_437( let __v_37: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_37]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39471,7 +37916,6 @@ fn aiur_fn_437( let __v_37: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_37]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39483,14 +37927,12 @@ fn aiur_fn_437( let __v_37: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_37]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_437] = [__v_37]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39530,7 +37972,6 @@ fn aiur_fn_438( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_438] = [__v_4, __v_7]; record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39566,11 +38007,10 @@ fn aiur_fn_438( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); let __ret: [G; OUT_438] = [__v_39, __v_40]; record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39613,14 +38053,12 @@ fn aiur_fn_439( let __v_17: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_16, __v_17]; record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_16, __v_0]; record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39636,14 +38074,12 @@ fn aiur_fn_439( let __v_17: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_16, __v_17]; record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_16, __v_0]; record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39652,7 +38088,6 @@ fn aiur_fn_439( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_14, __v_0]; record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39679,7 +38114,6 @@ fn aiur_fn_440( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_4]; record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -39707,21 +38141,19 @@ fn aiur_fn_441( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_6]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_441] = [__v_12]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -39753,7 +38185,6 @@ fn aiur_fn_441( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_22]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -39764,44 +38195,41 @@ fn aiur_fn_441( let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_12]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_441] = [__v_12]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_441] = [__v_13]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -39815,7 +38243,6 @@ fn aiur_fn_441( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_9]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -39823,7 +38250,6 @@ fn aiur_fn_441( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_6]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -39831,7 +38257,6 @@ fn aiur_fn_441( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_6]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39867,7 +38292,6 @@ fn aiur_fn_442( 0u64 => { let __ret: [G; OUT_442] = [__v_0]; record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39876,7 +38300,6 @@ fn aiur_fn_442( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_9]; record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -39906,12 +38329,11 @@ fn aiur_fn_442( let __v_12: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_15]; record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39943,13 +38365,12 @@ fn aiur_fn_442( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_23]; record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -39985,12 +38406,11 @@ fn aiur_fn_443( let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_443] = [__v_8]; record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -39999,12 +38419,11 @@ fn aiur_fn_443( let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_443] = [__v_8]; record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40041,12 +38460,11 @@ fn aiur_fn_444( 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_13]; record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40075,7 +38493,6 @@ fn aiur_fn_445( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_445] = [__v_3]; record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40089,20 +38506,18 @@ fn aiur_fn_445( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_445] = [__v_12]; record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_445] = [__v_3]; record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40128,7 +38543,6 @@ fn aiur_fn_446( 0u64 => { let __ret: [G; OUT_446] = []; record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40136,7 +38550,7 @@ fn aiur_fn_446( let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); @@ -40145,7 +38559,6 @@ fn aiur_fn_446( } let __ret: [G; OUT_446] = []; record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40170,7 +38583,6 @@ fn aiur_fn_447( 0u64 => { let __ret: [G; OUT_447] = []; record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40178,14 +38590,13 @@ fn aiur_fn_447( let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_447] = []; record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40197,7 +38608,6 @@ fn aiur_fn_447( } let __ret: [G; OUT_447] = []; record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40236,13 +38646,12 @@ fn aiur_fn_448( let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_448] = [__v_8]; record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; @@ -40252,7 +38661,6 @@ fn aiur_fn_448( let __v_18: G = __r_arr[0]; let __ret: [G; OUT_448] = [__v_18]; record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -40346,7 +38754,6 @@ fn aiur_fn_449( let __v_45: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_45]; record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40391,7 +38798,6 @@ fn aiur_fn_450( 1u64 => { let __ret: [G; OUT_450] = [__v_5]; record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -40424,7 +38830,6 @@ fn aiur_fn_451( } let __ret: [G; OUT_451] = []; record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40471,10 +38876,9 @@ fn aiur_fn_452( let __v_29: G = G::from_u64(38); let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(190); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_452] = [__v_32]; record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40521,10 +38925,9 @@ fn aiur_fn_453( let __v_29: G = G::from_u64(237); let __v_30: G = G::from_u64(137); let __v_31: G = G::from_u64(87); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_453] = [__v_32]; record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40571,10 +38974,9 @@ fn aiur_fn_454( let __v_29: G = G::from_u64(103); let __v_30: G = G::from_u64(146); let __v_31: G = G::from_u64(29); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_454] = [__v_32]; record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40621,10 +39023,9 @@ fn aiur_fn_455( let __v_29: G = G::from_u64(169); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(129); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_455] = [__v_32]; record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40671,10 +39072,9 @@ fn aiur_fn_456( let __v_29: G = G::from_u64(188); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(149); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_456] = [__v_32]; record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40721,10 +39121,9 @@ fn aiur_fn_457( let __v_29: G = G::from_u64(216); let __v_30: G = G::from_u64(240); 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_457] = [__v_32]; record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40771,10 +39170,9 @@ fn aiur_fn_458( let __v_29: G = G::from_u64(225); let __v_30: G = G::from_u64(109); let __v_31: G = G::from_u64(72); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_458] = [__v_32]; record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40821,10 +39219,9 @@ fn aiur_fn_459( let __v_29: G = G::from_u64(234); let __v_30: G = G::from_u64(96); let __v_31: G = G::from_u64(183); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_459] = [__v_32]; record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40871,10 +39268,9 @@ fn aiur_fn_460( let __v_29: G = G::from_u64(60); let __v_30: G = G::from_u64(251); let __v_31: G = G::from_u64(200); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_460] = [__v_32]; record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40921,10 +39317,9 @@ fn aiur_fn_461( let __v_29: G = G::from_u64(201); let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_461] = [__v_32]; record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -40971,10 +39366,9 @@ fn aiur_fn_462( let __v_29: G = G::from_u64(167); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(206); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_462] = [__v_32]; record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -41021,10 +39415,9 @@ fn aiur_fn_463( let __v_29: G = G::from_u64(194); let __v_30: G = G::from_u64(7); 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_463] = [__v_32]; record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -41071,10 +39464,9 @@ fn aiur_fn_464( let __v_29: G = G::from_u64(212); let __v_30: G = G::from_u64(116); let __v_31: G = G::from_u64(79); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_464] = [__v_32]; record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -41121,10 +39513,9 @@ fn aiur_fn_465( let __v_29: G = G::from_u64(16); let __v_30: G = G::from_u64(249); let __v_31: G = G::from_u64(86); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_465] = [__v_32]; record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -41171,10 +39562,9 @@ fn aiur_fn_466( let __v_29: G = G::from_u64(132); let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(220); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_466] = [__v_32]; record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -41221,10 +39611,9 @@ fn aiur_fn_467( let __v_29: G = G::from_u64(241); let __v_30: G = G::from_u64(73); let __v_31: G = G::from_u64(241); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_467] = [__v_32]; record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -41249,7 +39638,6 @@ fn aiur_fn_468( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_3]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41262,7 +39650,6 @@ fn aiur_fn_468( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_5]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41275,7 +39662,6 @@ fn aiur_fn_468( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_7]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41288,7 +39674,6 @@ fn aiur_fn_468( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_9]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41301,7 +39686,6 @@ fn aiur_fn_468( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_11]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41314,14 +39698,12 @@ fn aiur_fn_468( let __v_13: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41358,7 +39740,6 @@ fn aiur_fn_469( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_469] = [__v_3]; record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41371,7 +39752,6 @@ fn aiur_fn_469( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_469] = [__v_5]; record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41384,14 +39764,12 @@ fn aiur_fn_469( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_469] = [__v_7]; record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_7]; record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41442,10 +39820,9 @@ fn aiur_fn_470( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_470] = [__v_14, __v_15, __v_18]; record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41461,7 +39838,6 @@ fn aiur_fn_470( let __v_18: G = G::from_u64(1); let __ret: [G; OUT_470] = [__v_18, __v_12, __v_16]; record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41469,10 +39845,9 @@ fn aiur_fn_470( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_470] = [__v_18, __v_19, __v_22]; record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41482,10 +39857,9 @@ fn aiur_fn_470( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_470] = [__v_18, __v_19, __v_22]; record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41497,10 +39871,9 @@ fn aiur_fn_470( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_470] = [__v_9, __v_10, __v_13]; record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41510,10 +39883,9 @@ fn aiur_fn_470( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_470] = [__v_5, __v_6, __v_9]; record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41549,19 +39921,18 @@ fn aiur_fn_471( let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(7); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_471] = [__v_15]; record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -41590,10 +39961,9 @@ fn aiur_fn_472( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_472] = [__v_7, __v_11]; record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41619,10 +39989,9 @@ fn aiur_fn_472( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_472] = [__v_17, __v_21]; record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41631,7 +40000,6 @@ fn aiur_fn_472( let __v_18: G = __r_arr[1]; let __ret: [G; OUT_472] = [__v_17, __v_18]; record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41642,7 +40010,6 @@ fn aiur_fn_472( let __v_15: G = __r_arr[1]; let __ret: [G; OUT_472] = [__v_14, __v_15]; record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41689,13 +40056,13 @@ fn aiur_fn_473( let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(2); let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -41704,7 +40071,6 @@ fn aiur_fn_473( let __v_28: G = __r_arr[0]; let __ret: [G; OUT_473] = [__v_27, __v_28]; record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41712,10 +40078,9 @@ fn aiur_fn_473( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_473] = [__v_14, __v_18]; record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41725,10 +40090,9 @@ fn aiur_fn_473( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_473] = [__v_11, __v_15]; record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41759,10 +40123,9 @@ fn aiur_fn_474( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_474] = [__v_7, __v_11]; record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41775,7 +40138,6 @@ fn aiur_fn_474( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_474] = [__v_8, __v_9]; record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41798,7 +40160,6 @@ fn aiur_fn_474( let __v_15: G = __r_arr[1]; let __ret: [G; OUT_474] = [__v_14, __v_15]; record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41807,7 +40168,6 @@ fn aiur_fn_474( let __v_15: G = __r_arr[1]; let __ret: [G; OUT_474] = [__v_14, __v_15]; record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -41848,10 +40208,9 @@ fn aiur_fn_475( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_475] = [__v_10, __v_14]; record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -41863,13 +40222,13 @@ fn aiur_fn_475( let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(2); let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; @@ -41878,7 +40237,6 @@ fn aiur_fn_475( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_475] = [__v_24, __v_25]; record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -41923,10 +40281,9 @@ fn aiur_fn_476( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_476] = [__v_14, __v_18]; record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -41939,10 +40296,9 @@ fn aiur_fn_476( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_476] = [__v_16, __v_20]; record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -41965,7 +40321,6 @@ fn aiur_fn_476( let __v_18: G = __r_arr[1]; let __ret: [G; OUT_476] = [__v_17, __v_18]; record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42008,37 +40363,36 @@ fn aiur_fn_477( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_477] = [__v_12, __v_16]; record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(2); let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(2); let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; @@ -42056,15 +40410,15 @@ fn aiur_fn_477( let __v_35: G = G::from_u64(2); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { @@ -42100,24 +40454,23 @@ fn aiur_fn_477( let __v_48: G = G::from_u64(2); let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(3); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_57: G = G::from_u64(3); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __ret: [G; OUT_477] = [__v_63, __v_64]; record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42147,10 +40500,9 @@ fn aiur_fn_478( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_478] = [__v_6, __v_10]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42186,10 +40538,9 @@ fn aiur_fn_478( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_478] = [__v_19, __v_23]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42198,7 +40549,6 @@ fn aiur_fn_478( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_478] = [__v_19, __v_20]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42208,10 +40558,9 @@ fn aiur_fn_478( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_478] = [__v_18, __v_22]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42221,10 +40570,9 @@ fn aiur_fn_478( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_478] = [__v_18, __v_22]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42234,10 +40582,9 @@ fn aiur_fn_478( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_478] = [__v_14, __v_18]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42247,10 +40594,9 @@ fn aiur_fn_478( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_478] = [__v_14, __v_18]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42276,43 +40622,43 @@ fn aiur_fn_479( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(2); let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(2); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(0); - let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = G::from_u64(3); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(2); let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(2); let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; @@ -42335,10 +40681,9 @@ fn aiur_fn_479( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_479] = [__v_52, __v_56]; record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42350,15 +40695,15 @@ fn aiur_fn_479( let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); - let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(0); - let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_61: G = G::from_u64(3); let __v_62: G = G::from_u64(0); - let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_64: G = G::from_u64(3); let __v_65: G = G::from_u64(0); - let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_67: G = G::from_u64(2); let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; @@ -42367,7 +40712,6 @@ fn aiur_fn_479( let __v_70: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_69, __v_70]; record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42406,7 +40750,7 @@ fn aiur_fn_480( let __v_6: G = __mc_out___mc_0[0]; let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -42429,10 +40773,9 @@ fn aiur_fn_480( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_480] = [__v_20, __v_24]; record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42442,15 +40785,15 @@ fn aiur_fn_480( let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = G::from_u64(3); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(2); let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; @@ -42459,7 +40802,6 @@ fn aiur_fn_480( let __v_37: G = __r_arr[0]; let __ret: [G; OUT_480] = [__v_36, __v_37]; record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42484,7 +40826,6 @@ fn aiur_fn_481( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_481] = [__v_3]; record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42494,14 +40835,12 @@ fn aiur_fn_481( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_481] = [__v_4]; record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __ret: [G; OUT_481] = [__v_4]; record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42529,13 +40868,11 @@ fn aiur_fn_482( 1u64 => { let __ret: [G; OUT_482] = [__v_1]; record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_482] = [__v_0]; record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42556,7 +40893,6 @@ fn aiur_fn_483( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_483] = [__v_0, __v_1]; record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -42575,7 +40911,6 @@ fn aiur_fn_484( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_484] = [__v_0, __v_1]; record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -42594,7 +40929,6 @@ fn aiur_fn_485( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_0, __v_1]; record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -42618,13 +40952,11 @@ fn aiur_fn_486( let __v_4: G = (__v_1 * __v_3); let __ret: [G; OUT_486] = [__v_2, __v_4]; record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_486] = [__v_0, __v_1]; record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42645,7 +40977,6 @@ fn aiur_fn_487( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_487] = [__v_0, __v_1]; record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -42760,7 +41091,6 @@ fn aiur_fn_488( let __v_80: G = __r_arr[0]; let __ret: [G; OUT_488] = [__v_80]; record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -42805,7 +41135,6 @@ fn aiur_fn_489( let __v_26: G = __r_arr[0]; let __ret: [G; OUT_489] = [__v_26]; record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -42832,7 +41161,6 @@ fn aiur_fn_490( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_490] = [__v_6]; record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -42844,7 +41172,6 @@ fn aiur_fn_490( let __v_8: G = (__v_7 + __v_4); let __ret: [G; OUT_490] = [__v_8]; record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42852,7 +41179,6 @@ fn aiur_fn_490( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_490] = [__v_7]; record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42886,7 +41212,6 @@ fn aiur_fn_491( let __v_5: G = __r_arr[1]; let __ret: [G; OUT_491] = [__v_4, __v_5]; record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42905,7 +41230,6 @@ fn aiur_fn_491( let __v_8: G = __r_arr[1]; let __ret: [G; OUT_491] = [__v_7, __v_8]; record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42914,7 +41238,6 @@ fn aiur_fn_491( let __v_7: G = __r_arr[1]; let __ret: [G; OUT_491] = [__v_6, __v_7]; record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42927,7 +41250,6 @@ fn aiur_fn_491( let __v_7: G = __r_arr[1]; let __ret: [G; OUT_491] = [__v_6, __v_7]; record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -42936,7 +41258,6 @@ fn aiur_fn_491( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_491] = [__v_6, __v_7]; record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42974,14 +41295,12 @@ fn aiur_fn_492( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -42996,7 +41315,6 @@ fn aiur_fn_492( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43004,14 +41322,12 @@ fn aiur_fn_492( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43026,14 +41342,12 @@ fn aiur_fn_492( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -43045,14 +41359,12 @@ fn aiur_fn_492( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_492] = [__v_10]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43067,21 +41379,18 @@ fn aiur_fn_492( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -43093,14 +41402,12 @@ fn aiur_fn_492( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_492] = [__v_10]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43119,14 +41426,12 @@ fn aiur_fn_492( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_492] = [__v_8]; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43165,14 +41470,12 @@ fn aiur_fn_493( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_493] = [__v_8]; record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_493] = [__v_8]; record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43187,7 +41490,6 @@ fn aiur_fn_493( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_493] = [__v_8]; record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -43199,7 +41501,6 @@ fn aiur_fn_493( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_493] = [__v_10]; record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43236,14 +41537,12 @@ fn aiur_fn_494( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_4]; record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_494] = [__v_4]; record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43257,7 +41556,6 @@ fn aiur_fn_494( let __v_4: G = G::from_u64(2); let __ret: [G; OUT_494] = [__v_4]; record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43265,7 +41563,6 @@ fn aiur_fn_494( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_4]; record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43308,13 +41605,11 @@ fn aiur_fn_495( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_495] = [__v_7]; record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_495] = [__v_6]; record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43349,7 +41644,6 @@ fn aiur_fn_496( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_496] = [__v_12]; record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -43374,7 +41668,6 @@ fn aiur_fn_496( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_496] = [__v_24]; record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43447,7 +41740,6 @@ fn aiur_fn_497( let __v_30: G = __r_arr[0]; let __ret: [G; OUT_497] = [__v_30]; record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -43479,14 +41771,12 @@ fn aiur_fn_498( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_498] = [__v_8]; record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_498] = [__v_8]; record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43501,7 +41791,6 @@ fn aiur_fn_498( let __v_8: G = G::from_u64(2); let __ret: [G; OUT_498] = [__v_8]; record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -43513,7 +41802,6 @@ fn aiur_fn_498( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_498] = [__v_10]; record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43549,7 +41837,6 @@ fn aiur_fn_499( let __v_5: G = __r_arr[1]; let __ret: [G; OUT_499] = [__v_4, __v_5]; record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43568,7 +41855,6 @@ fn aiur_fn_499( let __v_13: G = __r_arr[1]; let __ret: [G; OUT_499] = [__v_12, __v_13]; record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43605,7 +41891,6 @@ fn aiur_fn_500( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_10, __v_11]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43614,7 +41899,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43627,7 +41911,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43638,7 +41921,6 @@ fn aiur_fn_500( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_10, __v_11]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43647,7 +41929,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43660,7 +41941,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43669,7 +41949,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -43686,7 +41965,6 @@ fn aiur_fn_500( let __v_15: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_14, __v_15]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43695,7 +41973,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43708,7 +41985,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43717,7 +41993,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -43726,7 +42001,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -43741,7 +42015,6 @@ fn aiur_fn_500( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_13, __v_14]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43750,7 +42023,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43763,7 +42035,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43772,7 +42043,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -43781,7 +42051,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -43790,7 +42059,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -43805,7 +42073,6 @@ fn aiur_fn_500( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_13, __v_14]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43814,7 +42081,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43827,7 +42093,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43836,7 +42101,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -43845,7 +42109,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -43854,7 +42117,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -43863,7 +42125,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -43878,7 +42139,6 @@ fn aiur_fn_500( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_13, __v_14]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43887,7 +42147,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43900,7 +42159,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -43909,7 +42167,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -43918,7 +42175,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -43927,7 +42183,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -43936,7 +42191,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -43945,7 +42199,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -43966,7 +42219,6 @@ fn aiur_fn_500( let __v_18: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_17, __v_18]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -43975,7 +42227,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -43988,7 +42239,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -43999,7 +42249,6 @@ fn aiur_fn_500( let __v_11: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_10, __v_11]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44008,7 +42257,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44035,7 +42283,6 @@ fn aiur_fn_500( let __v_19: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_18, __v_19]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44044,7 +42291,6 @@ fn aiur_fn_500( let __v_10: G = __r_arr[1]; let __ret: [G; OUT_500] = [__v_9, __v_10]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44090,7 +42336,6 @@ fn aiur_fn_501( let __v_13: G = __r_arr[1]; let __ret: [G; OUT_501] = [__v_12, __v_13]; record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44133,7 +42378,6 @@ fn aiur_fn_502( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_502] = [__v_13, __v_14]; record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44142,7 +42386,6 @@ fn aiur_fn_502( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_502] = [__v_13, __v_14]; record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44161,7 +42404,6 @@ fn aiur_fn_502( let __v_14: G = __r_arr[1]; let __ret: [G; OUT_502] = [__v_13, __v_14]; record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -44176,7 +42418,6 @@ fn aiur_fn_502( let __v_18: G = __r_arr[1]; let __ret: [G; OUT_502] = [__v_17, __v_18]; record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44218,56 +42459,48 @@ fn aiur_fn_503( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); let __ret: [G; OUT_503] = [__v_12]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44325,7 +42558,6 @@ fn aiur_fn_504( let __v_29: G = __r_arr[1]; let __ret: [G; OUT_504] = [__v_28, __v_29]; record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44334,7 +42566,6 @@ fn aiur_fn_504( let __v_29: G = __r_arr[1]; let __ret: [G; OUT_504] = [__v_28, __v_29]; record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44399,7 +42630,6 @@ fn aiur_fn_505( let __v_35: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_34, __v_35]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44408,7 +42638,6 @@ fn aiur_fn_505( let __v_26: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_25, __v_26]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44464,7 +42693,6 @@ fn aiur_fn_505( let __v_52: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_51, __v_52]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44476,7 +42704,6 @@ fn aiur_fn_505( let __v_47: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_46, __v_47]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44487,7 +42714,6 @@ fn aiur_fn_505( let __v_26: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_25, __v_26]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44554,7 +42780,6 @@ fn aiur_fn_505( let __v_60: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_59, __v_60]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44563,7 +42788,6 @@ fn aiur_fn_505( let __v_26: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_25, __v_26]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44574,7 +42798,6 @@ fn aiur_fn_505( let __v_26: G = __r_arr[1]; let __ret: [G; OUT_505] = [__v_25, __v_26]; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44606,7 +42829,6 @@ fn aiur_fn_506( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_506] = [__v_8, __v_9]; record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44653,7 +42875,6 @@ fn aiur_fn_506( let __v_41: G = __r_arr[1]; let __ret: [G; OUT_506] = [__v_40, __v_41]; record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44736,7 +42957,6 @@ fn aiur_fn_507( let __v_46: G = __r_arr[1]; let __ret: [G; OUT_507] = [__v_45, __v_46]; record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -44751,7 +42971,6 @@ fn aiur_fn_507( let __v_29: G = __r_arr[1]; let __ret: [G; OUT_507] = [__v_28, __v_29]; record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44768,7 +42987,6 @@ fn aiur_fn_507( let __v_29: G = __r_arr[1]; let __ret: [G; OUT_507] = [__v_28, __v_29]; record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44810,23 +43028,22 @@ fn aiur_fn_508( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_34]; record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -44862,7 +43079,6 @@ fn aiur_fn_509( let __v_15: G = __loaded[11]; let __ret: [G; OUT_509] = [__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[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -44896,14 +43112,12 @@ fn aiur_fn_510( 5u64 => { let __ret: [G; OUT_510] = [__v_7]; record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_510] = [__v_14]; record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -44930,7 +43144,6 @@ fn aiur_fn_511( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_5]; record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -44958,10 +43171,9 @@ fn aiur_fn_512( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_512] = [__v_10]; record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -44977,7 +43189,6 @@ fn aiur_fn_512( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_512] = [__v_14]; record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45010,11 +43221,10 @@ fn aiur_fn_513( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __ret: [G; OUT_513] = [__v_10, __v_11]; record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45031,19 +43241,17 @@ fn aiur_fn_513( let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __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_513] = [__v_16, __v_10]; record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_513] = [__v_16, __v_9]; record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45075,10 +43283,9 @@ fn aiur_fn_514( 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_514] = [__v_8]; record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45090,10 +43297,9 @@ fn aiur_fn_514( let __v_10: G = (__v_4 + __v_9); let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_514] = [__v_12]; record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45116,8 +43322,8 @@ fn aiur_fn_515( let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -45126,7 +43332,6 @@ fn aiur_fn_515( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_515] = [__v_11]; record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -45149,7 +43354,6 @@ fn aiur_fn_516( 0u64 => { let __ret: [G; OUT_516] = [__v_0]; record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45163,7 +43367,6 @@ fn aiur_fn_516( 1u64 => { let __ret: [G; OUT_516] = [__v_0]; record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45173,7 +43376,6 @@ fn aiur_fn_516( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_516] = [__v_9]; record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45203,10 +43405,9 @@ fn aiur_fn_517( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_517] = [__v_8]; record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45218,7 +43419,6 @@ fn aiur_fn_517( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_517] = [__v_8]; record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45247,21 +43447,19 @@ fn aiur_fn_518( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_518] = [__v_6]; record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_518] = [__v_8]; record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45271,7 +43469,6 @@ fn aiur_fn_518( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_518] = [__v_5]; record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45299,10 +43496,9 @@ fn aiur_fn_519( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_519] = [__v_8]; record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45312,7 +43508,6 @@ fn aiur_fn_519( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_519] = [__v_7]; record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45345,11 +43540,10 @@ fn aiur_fn_520( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_520] = [__v_11]; record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45385,20 +43579,18 @@ fn aiur_fn_520( match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_520] = [__v_34]; record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_520] = [__v_35]; record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45431,23 +43623,21 @@ fn aiur_fn_521( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_521] = [__v_8]; record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_521] = [__v_11]; record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45481,11 +43671,10 @@ fn aiur_fn_522( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_522] = [__v_12]; record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45526,7 +43715,6 @@ fn aiur_fn_522( let __v_35: G = __r_arr[0]; let __ret: [G; OUT_522] = [__v_35]; record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45534,14 +43722,13 @@ fn aiur_fn_522( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_522] = [__v_41]; record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45580,14 +43767,12 @@ fn aiur_fn_523( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_523] = [__v_8]; record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_523] = [__v_8]; record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45602,7 +43787,6 @@ fn aiur_fn_523( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_523] = [__v_8]; record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45613,7 +43797,6 @@ fn aiur_fn_523( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_523] = [__v_9]; record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45621,7 +43804,6 @@ fn aiur_fn_523( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_523] = [__v_9]; record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45657,10 +43839,9 @@ fn aiur_fn_524( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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]; record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45670,7 +43851,6 @@ fn aiur_fn_524( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_524] = [__v_5]; record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45700,7 +43880,6 @@ fn aiur_fn_525( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_525] = [__v_4]; record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45712,14 +43891,12 @@ fn aiur_fn_525( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_525] = [__v_5]; record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_525] = [__v_5]; record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45795,10 +43972,9 @@ fn aiur_fn_526( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_526] = [__v_51]; record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45809,16 +43985,14 @@ fn aiur_fn_526( match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_526] = [__v_53]; record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_526] = [__v_51]; record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -45895,7 +44069,6 @@ fn aiur_fn_527( let __v_49: G = G::from_u64(0); let __ret: [G; OUT_527] = [__v_49]; record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -45923,7 +44096,6 @@ fn aiur_fn_527( let __v_50: G = G::from_u64(1); let __ret: [G; OUT_527] = [__v_50]; record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -45931,7 +44103,6 @@ fn aiur_fn_527( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_527] = [__v_50]; record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46029,7 +44200,6 @@ fn aiur_fn_528( 1u64 => { let __ret: [G; OUT_528] = []; record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46053,7 +44223,6 @@ fn aiur_fn_528( } let __ret: [G; OUT_528] = []; record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46061,7 +44230,6 @@ fn aiur_fn_528( _ => { let __ret: [G; OUT_528] = []; record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46096,7 +44264,6 @@ fn aiur_fn_529( 0u64 => { let __ret: [G; OUT_529] = [__v_3]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -46105,14 +44272,12 @@ fn aiur_fn_529( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_529] = [__v_12]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_529] = [__v_12]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46121,38 +44286,32 @@ fn aiur_fn_529( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_529] = [__v_12]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_529] = [__v_4]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_529] = [__v_12]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_529] = [__v_6]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_529] = [__v_8]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_529] = [__v_9]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46183,14 +44342,12 @@ fn aiur_fn_530( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_530] = [__v_5]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_530] = [__v_5]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -46215,7 +44372,6 @@ fn aiur_fn_530( let __v_20: G = (__v_18 - __v_19); let __ret: [G; OUT_530] = [__v_20]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -46226,7 +44382,6 @@ fn aiur_fn_530( let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_530] = [__v_7]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -46237,7 +44392,6 @@ fn aiur_fn_530( let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_530] = [__v_7]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -46248,7 +44402,6 @@ fn aiur_fn_530( let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_530] = [__v_7]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -46262,14 +44415,12 @@ fn aiur_fn_530( let __v_9: G = (__v_5 * __v_8); let __ret: [G; OUT_530] = [__v_9]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_530] = [__v_5]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -46277,7 +44428,6 @@ fn aiur_fn_530( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_530] = [__v_5]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46303,7 +44453,6 @@ fn aiur_fn_531( 1u64 => { let __ret: [G; OUT_531] = []; record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46315,7 +44464,6 @@ fn aiur_fn_531( } let __ret: [G; OUT_531] = []; record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46342,14 +44490,12 @@ fn aiur_fn_532( 0u64 => { let __ret: [G; OUT_532] = []; record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_532] = []; record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -46357,7 +44503,6 @@ fn aiur_fn_532( let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_532] = []; record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -46365,7 +44510,6 @@ fn aiur_fn_532( let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_532] = []; record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -46376,7 +44520,6 @@ fn aiur_fn_532( } let __ret: [G; OUT_532] = []; record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46406,7 +44549,6 @@ fn aiur_fn_533( 1u64 => { let __ret: [G; OUT_533] = []; record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -46414,7 +44556,6 @@ fn aiur_fn_533( let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_533] = []; record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46451,14 +44592,12 @@ fn aiur_fn_534( } let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -46487,7 +44626,6 @@ fn aiur_fn_534( let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -46495,7 +44633,6 @@ fn aiur_fn_534( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -46505,7 +44642,6 @@ fn aiur_fn_534( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -46515,7 +44651,6 @@ fn aiur_fn_534( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -46526,20 +44661,17 @@ fn aiur_fn_534( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_534] = []; record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46591,10 +44723,9 @@ fn aiur_fn_535( let __v_29: G = G::from_u64(99); let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(184); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_535] = [__v_32]; record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -46618,7 +44749,6 @@ fn aiur_fn_536( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_536] = [__v_4]; record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46635,14 +44765,12 @@ fn aiur_fn_536( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_536] = [__v_10]; record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_536] = [__v_8]; record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -46693,7 +44821,7 @@ fn aiur_fn_537( let __v_29: G = G::from_u64(200); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(201); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; @@ -46725,7 +44853,6 @@ fn aiur_fn_537( } let __ret: [G; OUT_537] = []; record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46822,7 +44949,6 @@ fn aiur_fn_538( } let __ret: [G; OUT_538] = []; record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -46843,7 +44969,6 @@ fn aiur_fn_539( 0u64 => { let __ret: [G; OUT_539] = [__v_0]; record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46860,7 +44985,6 @@ fn aiur_fn_539( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_539] = [__v_8]; record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46895,7 +45019,6 @@ fn aiur_fn_540( } let __ret: [G; OUT_540] = []; record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46921,7 +45044,6 @@ fn aiur_fn_540( } let __ret: [G; OUT_540] = []; record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46957,7 +45079,6 @@ fn aiur_fn_541( 0u64 => { let __ret: [G; OUT_541] = []; record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -46986,7 +45107,6 @@ fn aiur_fn_541( } let __ret: [G; OUT_541] = []; record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47044,7 +45164,6 @@ fn aiur_fn_542( } let __ret: [G; OUT_542] = []; record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47094,8 +45213,8 @@ fn aiur_fn_543( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_1 + __v_2); @@ -47110,7 +45229,6 @@ fn aiur_fn_543( } let __ret: [G; OUT_543] = []; record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47138,7 +45256,6 @@ fn aiur_fn_544( 0u64 => { let __ret: [G; OUT_544] = []; record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47159,7 +45276,7 @@ fn aiur_fn_544( let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = 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()) }); @@ -47169,7 +45286,6 @@ fn aiur_fn_544( let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_544] = []; record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47201,11 +45317,10 @@ fn aiur_fn_545( let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_545] = []; record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -47236,7 +45351,6 @@ fn aiur_fn_546( 1u64 => { let __ret: [G; OUT_546] = [__v_5]; record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47255,12 +45369,11 @@ fn aiur_fn_546( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_546] = [__v_12]; record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47301,17 +45414,15 @@ fn aiur_fn_547( return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor field lives in a universe above the inductive's".to_string()) }); } let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_547] = []; record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_547] = []; record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47337,7 +45448,6 @@ fn aiur_fn_548( let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_548] = []; record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47351,11 +45461,10 @@ fn aiur_fn_548( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_548] = []; record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47388,17 +45497,15 @@ fn aiur_fn_549( 0u64 => { let __ret: [G; OUT_549] = []; record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_549] = []; record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47421,7 +45528,6 @@ fn aiur_fn_550( let __v_2: G = __r_arr[0]; let __ret: [G; OUT_550] = [__v_2]; record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -47447,7 +45553,6 @@ fn aiur_fn_551( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_551] = [__v_5]; record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -47458,7 +45563,6 @@ fn aiur_fn_551( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_551] = [__v_6]; record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47466,7 +45570,6 @@ fn aiur_fn_551( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_551] = [__v_6]; record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47511,14 +45614,12 @@ fn aiur_fn_552( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_552] = [__v_15]; record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_552] = [__v_15]; record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47547,14 +45648,12 @@ fn aiur_fn_553( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_553] = [__v_6]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_553] = [__v_6]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -47562,7 +45661,6 @@ fn aiur_fn_553( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_6]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -47573,7 +45671,6 @@ fn aiur_fn_553( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_7]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47581,7 +45678,6 @@ fn aiur_fn_553( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_7]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47594,7 +45690,6 @@ fn aiur_fn_553( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_7]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47602,7 +45697,6 @@ fn aiur_fn_553( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_7]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47615,7 +45709,6 @@ fn aiur_fn_553( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_7]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47623,7 +45716,6 @@ fn aiur_fn_553( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_7]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47636,7 +45728,6 @@ fn aiur_fn_553( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_7]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47647,7 +45738,6 @@ fn aiur_fn_553( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_8]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47655,7 +45745,6 @@ fn aiur_fn_553( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_8]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47666,7 +45755,6 @@ fn aiur_fn_553( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_553] = [__v_6]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -47674,7 +45762,6 @@ fn aiur_fn_553( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_6]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47705,7 +45792,6 @@ fn aiur_fn_554( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_554] = [__v_5]; record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -47716,7 +45802,6 @@ fn aiur_fn_554( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_554] = [__v_6]; record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47724,7 +45809,6 @@ fn aiur_fn_554( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_554] = [__v_6]; record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47753,7 +45837,6 @@ fn aiur_fn_555( 0u64 => { let __ret: [G; OUT_555] = [__v_0, __v_2]; record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47765,7 +45848,7 @@ fn aiur_fn_555( match __v_3.as_canonical_u64() { 5u64 => { let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; @@ -47773,13 +45856,11 @@ fn aiur_fn_555( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_555] = [__v_11, __v_12]; record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_555] = [__v_0, __v_2]; record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -47807,7 +45888,6 @@ fn aiur_fn_556( 0u64 => { let __ret: [G; OUT_556] = []; record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47835,7 +45915,6 @@ fn aiur_fn_556( let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_556] = []; record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47904,7 +45983,6 @@ fn aiur_fn_557( } let __ret: [G; OUT_557] = []; record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47934,7 +46012,6 @@ fn aiur_fn_558( 0u64 => { let __ret: [G; OUT_558] = []; record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47948,7 +46025,7 @@ fn aiur_fn_558( match __v_6.as_canonical_u64() { 5u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); @@ -47958,7 +46035,6 @@ fn aiur_fn_558( let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_558] = []; record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -47983,13 +46059,11 @@ fn aiur_fn_558( let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_558] = []; record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_558] = []; record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48015,7 +46089,7 @@ fn aiur_fn_558( let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; @@ -48030,7 +46104,6 @@ fn aiur_fn_558( let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_558] = []; record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48073,7 +46146,6 @@ fn aiur_fn_559( 0u64 => { let __ret: [G; OUT_559] = []; record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48096,7 +46168,7 @@ fn aiur_fn_559( 6u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; @@ -48105,7 +46177,7 @@ fn aiur_fn_559( let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); @@ -48113,7 +46185,6 @@ fn aiur_fn_559( let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_559] = []; record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48148,17 +46219,15 @@ fn aiur_fn_560( 5u64 => { let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_560] = []; record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_560] = []; record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48182,8 +46251,8 @@ fn aiur_fn_561( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; @@ -48191,7 +46260,6 @@ fn aiur_fn_561( let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_561] = []; record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -48216,14 +46284,13 @@ fn aiur_fn_562( let __v_7: G = (__v_1 + __v_2); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_562] = []; record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -48252,7 +46319,6 @@ fn aiur_fn_563( 0u64 => { let __ret: [G; OUT_563] = []; record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48278,7 +46344,7 @@ fn aiur_fn_563( let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_13, __v_17, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_13, __v_17, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_14, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -48300,7 +46366,6 @@ fn aiur_fn_563( let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_563] = []; record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48339,13 +46404,11 @@ fn aiur_fn_564( let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_564] = []; record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_564] = []; record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48383,7 +46446,6 @@ fn aiur_fn_565( 1u64 => { let __ret: [G; OUT_565] = []; record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48444,13 +46506,11 @@ fn aiur_fn_565( let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_565] = []; record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_565] = []; record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48462,7 +46522,6 @@ fn aiur_fn_565( _ => { let __ret: [G; OUT_565] = []; record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48538,7 +46597,6 @@ fn aiur_fn_566( 1u64 => { let __ret: [G; OUT_566] = []; record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -48553,7 +46611,6 @@ fn aiur_fn_566( let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_566] = []; record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48578,13 +46635,13 @@ fn aiur_fn_566( let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); - let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; if (__v_60 != __v_2) { @@ -48601,7 +46658,6 @@ fn aiur_fn_566( let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_566] = []; record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48610,7 +46666,6 @@ fn aiur_fn_566( let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_566] = []; record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48623,7 +46678,6 @@ fn aiur_fn_566( let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_566] = []; record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48667,7 +46721,6 @@ fn aiur_fn_567( let __v_16: G = G::from_u64(1); let __ret: [G; OUT_567] = [__v_16]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48676,7 +46729,6 @@ fn aiur_fn_567( let __v_16: G = G::from_u64(1); let __ret: [G; OUT_567] = [__v_16]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -48685,7 +46737,6 @@ fn aiur_fn_567( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_567] = [__v_16]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48696,18 +46747,16 @@ fn aiur_fn_567( let __v_16: G = G::from_u64(1); let __ret: [G; OUT_567] = [__v_16]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_9, __v_10, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_567] = [__v_19]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48716,7 +46765,6 @@ fn aiur_fn_567( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_567] = [__v_16]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48727,7 +46775,6 @@ fn aiur_fn_567( let __v_16: G = G::from_u64(0); let __ret: [G; OUT_567] = [__v_16]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48755,12 +46802,11 @@ fn aiur_fn_568( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_568] = [__v_8]; record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48772,21 +46818,19 @@ fn aiur_fn_568( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_568] = [__v_12]; record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_568] = [__v_8]; record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48820,7 +46864,6 @@ fn aiur_fn_569( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_569] = [__v_8]; record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48836,7 +46879,7 @@ fn aiur_fn_569( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); @@ -48849,28 +46892,26 @@ fn aiur_fn_569( }, _ => { let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_0 [__v_21]; }, } }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_569] = [__v_25]; record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_569] = [__v_10]; record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48900,7 +46941,6 @@ fn aiur_fn_570( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_570] = [__v_5]; record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -48911,7 +46951,6 @@ fn aiur_fn_570( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_570] = [__v_6]; record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48919,7 +46958,6 @@ fn aiur_fn_570( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_570] = [__v_6]; record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48952,7 +46990,6 @@ fn aiur_fn_571( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_571] = [__v_5]; record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -48969,7 +47006,6 @@ fn aiur_fn_571( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_571] = [__v_10]; record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -48977,7 +47013,6 @@ fn aiur_fn_571( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_571] = [__v_10]; record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -48987,7 +47022,6 @@ fn aiur_fn_571( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_571] = [__v_9]; record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49031,19 +47065,18 @@ fn aiur_fn_572( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_14]; record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = (__v_3 + __v_4); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { @@ -49051,7 +47084,6 @@ fn aiur_fn_572( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_23]; record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49078,14 +47110,12 @@ fn aiur_fn_572( let __v_37: G = G::from_bool((__v_32 == G::ZERO)); let __ret: [G; OUT_572] = [__v_37]; record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_37]; record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49094,7 +47124,6 @@ fn aiur_fn_572( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_23]; record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49107,7 +47136,6 @@ fn aiur_fn_572( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_13]; record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49133,7 +47161,6 @@ fn aiur_fn_573( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_573] = [__v_3]; record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49195,14 +47222,12 @@ fn aiur_fn_573( let __v_52: G = __r_arr[0]; let __ret: [G; OUT_573] = [__v_52]; record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); let __ret: [G; OUT_573] = [__v_51]; record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49280,14 +47305,12 @@ fn aiur_fn_574( let __v_49: G = G::from_u64(1); let __ret: [G; OUT_574] = [__v_49]; record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_574] = [__v_49]; record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49363,14 +47386,12 @@ fn aiur_fn_575( let __v_49: G = G::from_u64(1); let __ret: [G; OUT_575] = [__v_49]; record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_575] = [__v_49]; record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49384,7 +47405,6 @@ fn aiur_fn_575( let __v_51: G = __r_arr[0]; let __ret: [G; OUT_575] = [__v_51]; record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49392,7 +47412,6 @@ fn aiur_fn_575( let __v_49: G = __r_arr[0]; let __ret: [G; OUT_575] = [__v_49]; record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49443,7 +47462,6 @@ fn aiur_fn_576( 2u64 => { let __ret: [G; OUT_576] = [__v_16]; record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49506,16 +47524,14 @@ fn aiur_fn_577( 2u64 => { let __ret: [G; OUT_577] = [__v_24]; record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_577] = [__v_28]; record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49523,10 +47539,9 @@ fn aiur_fn_577( _ => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_577] = [__v_22]; record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49534,10 +47549,9 @@ fn aiur_fn_577( _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_577] = [__v_14]; record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49583,7 +47597,6 @@ fn aiur_fn_578( let __v_19: G = __r_arr[0]; let __ret: [G; OUT_578] = [__v_19]; record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49613,10 +47626,9 @@ fn aiur_fn_579( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_579] = [__v_7]; record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -49633,10 +47645,9 @@ fn aiur_fn_579( let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_579] = [__v_12]; record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49664,10 +47675,9 @@ fn aiur_fn_580( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_580] = [__v_6]; record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49675,15 +47685,14 @@ fn aiur_fn_580( let __v_5: G = G::from_u64(4); let __v_6: G = (__v_0 + __v_2); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_580] = [__v_12]; record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49760,7 +47769,6 @@ fn aiur_fn_581( let __v_51: G = __r_arr[0]; let __ret: [G; OUT_581] = [__v_51]; record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49788,23 +47796,21 @@ fn aiur_fn_581( let __v_66: G = G::from_u64(0); let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(1); - let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_581] = [__v_73]; record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); - let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_581] = [__v_65]; record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49882,10 +47888,9 @@ fn aiur_fn_582( 1u64 => { let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_582] = [__v_54]; record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -49926,15 +47931,14 @@ fn aiur_fn_582( let __v_70: G = G::from_u64(0); let __v_71: G = G::from_u64(1); let __v_72: G = G::from_u64(1); - let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_582] = [__v_77]; record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49944,7 +47948,6 @@ fn aiur_fn_582( let __v_54: G = __r_arr[0]; let __ret: [G; OUT_582] = [__v_54]; record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -49981,7 +47984,6 @@ fn aiur_fn_583( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_583] = [__v_9]; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -49998,7 +48000,6 @@ fn aiur_fn_583( let __v_11: G = G::from_u64(1); let __ret: [G; OUT_583] = [__v_11]; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50006,7 +48007,6 @@ fn aiur_fn_583( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_583] = [__v_11]; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50016,7 +48016,6 @@ fn aiur_fn_583( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_583] = [__v_10]; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50026,7 +48025,6 @@ fn aiur_fn_583( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_583] = [__v_9]; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50056,7 +48054,6 @@ fn aiur_fn_584( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_584] = [__v_3]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50080,14 +48077,12 @@ fn aiur_fn_584( let __v_12: G = G::from_u64(1); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50096,7 +48091,6 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50113,14 +48107,12 @@ fn aiur_fn_584( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50141,14 +48133,12 @@ fn aiur_fn_584( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50157,7 +48147,6 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50178,14 +48167,12 @@ fn aiur_fn_584( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50194,7 +48181,6 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50215,14 +48201,12 @@ fn aiur_fn_584( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50231,7 +48215,6 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50252,14 +48235,12 @@ fn aiur_fn_584( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50268,7 +48249,6 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50293,14 +48273,12 @@ fn aiur_fn_584( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_13]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_13]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50309,7 +48287,6 @@ fn aiur_fn_584( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50318,7 +48295,6 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50335,14 +48311,12 @@ fn aiur_fn_584( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50366,14 +48340,12 @@ fn aiur_fn_584( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_13]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_13]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50382,7 +48354,6 @@ fn aiur_fn_584( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_12]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50391,7 +48362,6 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_584] = [__v_11]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50432,14 +48402,12 @@ fn aiur_fn_585( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_585] = [__v_8]; record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_585] = [__v_8]; record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50454,7 +48422,6 @@ fn aiur_fn_585( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_585] = [__v_8]; record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -50466,14 +48433,12 @@ fn aiur_fn_585( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_585] = [__v_9]; record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_585] = [__v_9]; record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50517,14 +48482,12 @@ fn aiur_fn_586( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_586] = [__v_8]; record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_586] = [__v_8]; record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50539,7 +48502,6 @@ fn aiur_fn_586( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_586] = [__v_8]; record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -50551,14 +48513,12 @@ fn aiur_fn_586( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_586] = [__v_9]; record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_586] = [__v_9]; record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50604,16 +48564,14 @@ fn aiur_fn_587( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_587] = [__v_13]; record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_587] = [__v_15]; record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50690,13 +48648,11 @@ fn aiur_fn_588( let __v_51: G = __r_arr[0]; let __ret: [G; OUT_588] = [__v_51]; record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_588] = [__v_1]; record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50772,7 +48728,6 @@ fn aiur_fn_589( 1u64 => { let __ret: [G; OUT_589] = [__v_4]; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -50818,13 +48773,11 @@ fn aiur_fn_589( 5u64 => { let __ret: [G; OUT_589] = [__v_75]; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_589] = [__v_4]; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50832,7 +48785,6 @@ fn aiur_fn_589( _ => { let __ret: [G; OUT_589] = [__v_4]; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50844,7 +48796,6 @@ fn aiur_fn_589( let __v_54: G = __r_arr[0]; let __ret: [G; OUT_589] = [__v_54]; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50879,7 +48830,6 @@ fn aiur_fn_590( 0u64 => { let __ret: [G; OUT_590] = [__v_4]; record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -50887,7 +48837,6 @@ fn aiur_fn_590( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_6]; record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -50966,13 +48915,11 @@ fn aiur_fn_591( let __v_53: G = __r_arr[0]; let __ret: [G; OUT_591] = [__v_53]; record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_591] = [__v_3]; record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51050,7 +48997,6 @@ fn aiur_fn_592( 1u64 => { let __ret: [G; OUT_592] = [__v_5]; record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51140,7 +49086,6 @@ fn aiur_fn_592( let __v_75: G = __r_arr[0]; let __ret: [G; OUT_592] = [__v_75]; record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51158,7 +49103,6 @@ fn aiur_fn_592( let __v_78: G = __r_arr[0]; let __ret: [G; OUT_592] = [__v_78]; record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51171,7 +49115,6 @@ fn aiur_fn_592( let __v_80: G = __r_arr[0]; let __ret: [G; OUT_592] = [__v_80]; record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51185,7 +49128,6 @@ fn aiur_fn_592( let __v_56: G = __r_arr[0]; let __ret: [G; OUT_592] = [__v_56]; record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51223,7 +49165,6 @@ fn aiur_fn_593( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_593] = [__v_9, __v_10]; record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51234,7 +49175,6 @@ fn aiur_fn_593( let __v_10: G = G::from_u64(1); let __ret: [G; OUT_593] = [__v_10, __v_2]; record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51245,7 +49185,6 @@ fn aiur_fn_593( let __v_13: G = __r_arr[1]; let __ret: [G; OUT_593] = [__v_12, __v_13]; record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51285,7 +49224,6 @@ fn aiur_fn_594( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_594] = [__v_11, __v_12]; record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51324,7 +49262,6 @@ fn aiur_fn_594( let __v_17: G = G::from_u64(1); let __ret: [G; OUT_594] = [__v_17, __v_4]; record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51335,7 +49272,6 @@ fn aiur_fn_594( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_594] = [__v_19, __v_20]; record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51400,17 +49336,16 @@ fn aiur_fn_595( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_595] = [__v_40, __v_41, __v_44, __v_47]; record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51418,7 +49353,6 @@ fn aiur_fn_595( 0u64 => { let __ret: [G; OUT_595] = [__v_3, __v_4, __v_5, __v_6]; record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51431,7 +49365,6 @@ fn aiur_fn_595( let __v_13: G = __r_arr[3]; let __ret: [G; OUT_595] = [__v_10, __v_11, __v_12, __v_13]; record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51464,10 +49397,9 @@ fn aiur_fn_596( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_596] = [__v_9]; record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51480,7 +49412,6 @@ fn aiur_fn_596( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_596] = [__v_6]; record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51489,10 +49420,9 @@ fn aiur_fn_596( let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_8 - __v_0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_596] = [__v_11]; record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51521,7 +49451,6 @@ fn aiur_fn_597( 0u64 => { let __ret: [G; OUT_597] = [__v_0]; record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51545,7 +49474,6 @@ fn aiur_fn_597( let __v_17: G = __r_arr[0]; let __ret: [G; OUT_597] = [__v_17]; record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51573,10 +49501,9 @@ fn aiur_fn_598( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_598] = [__v_4]; record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51592,10 +49519,9 @@ fn aiur_fn_598( let __v_8: G = (__v_1 - __v_7); let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_598] = [__v_10]; record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51626,7 +49552,6 @@ fn aiur_fn_599( 0u64 => { let __ret: [G; OUT_599] = [__v_0]; record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51636,17 +49561,16 @@ fn aiur_fn_599( let __v_8: G = (__v_7 - __v_3); let __v_9: G = (__v_8 + __v_2); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_599] = [__v_17]; record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51674,7 +49598,6 @@ fn aiur_fn_600( 1u64 => { let __ret: [G; OUT_600] = [__v_0]; record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51683,12 +49606,11 @@ fn aiur_fn_600( let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_600] = [__v_11]; record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51720,7 +49642,6 @@ fn aiur_fn_601( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_601] = [__v_6]; record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51728,7 +49649,6 @@ fn aiur_fn_601( let __v_5: G = __r_arr[0]; let __ret: [G; OUT_601] = [__v_5]; record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51753,7 +49673,6 @@ fn aiur_fn_602( 0u64 => { let __ret: [G; OUT_602] = [__v_0]; record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51762,17 +49681,16 @@ fn aiur_fn_602( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_2 + __v_13); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_602] = [__v_15]; record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51799,7 +49717,6 @@ fn aiur_fn_603( 1u64 => { let __ret: [G; OUT_603] = [__v_0]; record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51807,10 +49724,9 @@ fn aiur_fn_603( let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_603] = [__v_8]; record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51836,10 +49752,9 @@ fn aiur_fn_604( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_604] = [__v_4, __v_0]; record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51856,16 +49771,15 @@ fn aiur_fn_604( let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_604] = [__v_11, __v_9]; record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -51881,19 +49795,17 @@ fn aiur_fn_604( let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_604] = [__v_19, __v_17]; record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_604] = [__v_16, __v_0]; record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -51925,10 +49837,9 @@ fn aiur_fn_605( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_605] = [__v_8]; record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -51939,10 +49850,9 @@ fn aiur_fn_605( let __v_9: G = (__v_2 + __v_8); let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_605] = [__v_11]; record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51974,7 +49884,6 @@ fn aiur_fn_606( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_606] = [__v_6]; record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -51983,7 +49892,6 @@ fn aiur_fn_606( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_606] = [__v_7]; record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52008,24 +49916,22 @@ fn aiur_fn_607( 0u64 => { let __ret: [G; OUT_607] = [__v_0]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_1 - __v_2); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_13]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52060,7 +49966,7 @@ fn aiur_fn_608( let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_15, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); @@ -52068,15 +49974,14 @@ fn aiur_fn_608( let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_608] = [__v_25]; record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -52099,7 +50004,6 @@ fn aiur_fn_609( let __v_4: G = __r_arr[0]; let __ret: [G; OUT_609] = [__v_4]; record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -52123,24 +50027,22 @@ fn aiur_fn_610( 0u64 => { let __ret: [G; OUT_610] = [__v_0]; record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = (__v_2 - __v_3); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_610] = [__v_14]; record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52167,7 +50069,6 @@ fn aiur_fn_611( 1u64 => { let __ret: [G; OUT_611] = [__v_0]; record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52175,10 +50076,9 @@ fn aiur_fn_611( let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_611] = [__v_8]; record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52234,7 +50134,6 @@ fn aiur_fn_612( let __v_27: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_27]; record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52242,7 +50141,6 @@ fn aiur_fn_612( let __v_27: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_27]; record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52299,7 +50197,7 @@ fn aiur_fn_613( let __v_27: G = __r_arr[3]; 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_24, __v_27, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_24, __v_27, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = (__v_4 + __v_11); let __v_32: G = (__v_31 + __v_19); let __v_33: G = (__v_32 + __v_5); @@ -52320,7 +50218,7 @@ fn aiur_fn_613( let __v_46: G = (__v_44 - __v_45); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_49, __v_5, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; @@ -52328,12 +50226,12 @@ fn aiur_fn_613( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 4] = [__v_52, __v_51, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_58: G = { let __values: [G; 4] = [__v_52, __v_51, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(5); let __v_60: G = G::from_u64(0); - let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_61, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_62, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; @@ -52344,7 +50242,6 @@ fn aiur_fn_613( let __v_65: G = __r_arr[0]; let __ret: [G; OUT_613] = [__v_65]; record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -52417,9 +50314,9 @@ fn aiur_fn_614( let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_35: G = 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]; @@ -52442,7 +50339,7 @@ fn aiur_fn_614( let __v_39: G = (__v_16 + __v_17); let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; @@ -52452,13 +50349,13 @@ fn aiur_fn_614( let __v_45: G = G::from_u64(4); 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_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_1 [__v_48]; }, _ => { let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_1 [__v_47]; }, } @@ -52492,7 +50389,7 @@ fn aiur_fn_614( _ => { let __v_58: G = G::from_u64(1); let __v_59: G = G::from_u64(1); - let __v_60: G = { let __values: [G; 3] = [__v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_60: G = { let __values: [G; 3] = [__v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_2 [__v_60]; }, } @@ -52507,7 +50404,6 @@ fn aiur_fn_614( let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_614] = []; record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52520,7 +50416,6 @@ fn aiur_fn_614( let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_614] = []; record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52533,7 +50428,6 @@ fn aiur_fn_614( _ => { let __ret: [G; OUT_614] = []; record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52588,7 +50482,7 @@ fn aiur_fn_615( let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); @@ -52599,7 +50493,6 @@ fn aiur_fn_615( let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_615] = []; record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -52623,7 +50516,6 @@ fn aiur_fn_616( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_616] = [__v_4]; record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52639,7 +50531,6 @@ fn aiur_fn_616( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_616] = [__v_10]; record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52676,7 +50567,6 @@ fn aiur_fn_616( let __v_27: G = (__v_23 + __v_26); let __ret: [G; OUT_616] = [__v_27]; record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52718,10 +50608,9 @@ fn aiur_fn_617( 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_617] = [__v_18]; record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52750,19 +50639,17 @@ fn aiur_fn_617( let __v_33: G = (__v_14 + __v_32); let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_617] = [__v_35]; record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_617] = [__v_31]; record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -52800,7 +50687,6 @@ fn aiur_fn_618( 1u64 => { let __ret: [G; OUT_618] = []; record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52849,7 +50735,6 @@ fn aiur_fn_618( 1u64 => { let __ret: [G; OUT_618] = []; record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52859,7 +50744,7 @@ fn aiur_fn_618( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; @@ -52869,7 +50754,7 @@ fn aiur_fn_618( } let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); @@ -52881,7 +50766,6 @@ fn aiur_fn_618( let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_618] = []; record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -52928,7 +50812,6 @@ fn aiur_fn_619( 1u64 => { let __ret: [G; OUT_619] = [__v_0]; record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -52967,7 +50850,7 @@ fn aiur_fn_619( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); @@ -52993,7 +50876,7 @@ fn aiur_fn_619( let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_69: G = G::from_u64(1); let __v_70: G = (__v_65 - __v_69); let __v_71: G = G::from_u64(0); @@ -53014,7 +50897,7 @@ fn aiur_fn_619( let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); - let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -53030,25 +50913,24 @@ fn aiur_fn_619( let __v_95: G = (__v_94 + __v_64); let __v_96: G = G::from_u64(0); let __v_97: G = G::from_u64(0); - let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_99: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); - let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_110]; record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53097,13 +50979,13 @@ fn aiur_fn_620( let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; @@ -53118,7 +51000,7 @@ fn aiur_fn_620( let __v_42: G = (__v_39 - __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; @@ -53127,7 +51009,6 @@ fn aiur_fn_620( let __v_49: G = __r_arr[0]; let __ret: [G; OUT_620] = [__v_49]; record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -53156,10 +51037,9 @@ fn aiur_fn_621( 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -53168,10 +51048,9 @@ fn aiur_fn_621( let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53254,13 +51133,11 @@ fn aiur_fn_622( let __v_54: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_54]; record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_622] = [__v_4]; record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53339,7 +51216,6 @@ fn aiur_fn_623( 1u64 => { let __ret: [G; OUT_623] = [__v_6]; record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -53427,7 +51303,6 @@ fn aiur_fn_623( 1u64 => { let __ret: [G; OUT_623] = [__v_55]; record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53437,7 +51312,6 @@ fn aiur_fn_623( let __v_72: G = __r_arr[0]; let __ret: [G; OUT_623] = [__v_72]; record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53449,7 +51323,6 @@ fn aiur_fn_623( let __v_57: G = __r_arr[0]; let __ret: [G; OUT_623] = [__v_57]; record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53483,10 +51356,9 @@ fn aiur_fn_624( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_624] = [__v_9]; record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -53519,10 +51391,9 @@ fn aiur_fn_624( let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_624] = [__v_23]; record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53567,23 +51438,22 @@ fn aiur_fn_625( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_625] = [__v_34]; record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -53618,10 +51488,9 @@ fn aiur_fn_626( 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_626] = [__v_18]; record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53653,10 +51522,9 @@ fn aiur_fn_626( let __v_35: G = (__v_14 + __v_34); let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_626] = [__v_37]; record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53689,7 +51557,6 @@ fn aiur_fn_627( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_7]; record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -53723,10 +51590,9 @@ fn aiur_fn_628( 1u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_628] = [__v_16]; record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -53761,7 +51627,6 @@ fn aiur_fn_628( let __v_34: G = __r_arr[0]; let __ret: [G; OUT_628] = [__v_34]; record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53771,7 +51636,6 @@ fn aiur_fn_628( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_628] = [__v_29]; record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53805,10 +51669,9 @@ fn aiur_fn_629( let __v_7: G = (__v_1 - __v_6); let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_629] = [__v_10]; record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53824,7 +51687,6 @@ fn aiur_fn_629( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_629] = [__v_9]; record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53833,10 +51695,9 @@ fn aiur_fn_629( let __v_9: G = (__v_1 - __v_8); let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_629] = [__v_12]; record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53870,13 +51731,11 @@ fn aiur_fn_630( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_630] = [__v_8]; record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_630] = [__v_1]; record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -53904,7 +51763,6 @@ fn aiur_fn_631( 0u64 => { let __ret: [G; OUT_631] = [__v_0]; record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -53928,13 +51786,12 @@ fn aiur_fn_631( let __v_18: G = __r_arr[0]; let __ret: [G; OUT_631] = [__v_18]; record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -53957,7 +51814,6 @@ fn aiur_fn_631( let __v_26: G = __r_arr[0]; let __ret: [G; OUT_631] = [__v_26]; record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54004,13 +51860,13 @@ fn aiur_fn_632( let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; @@ -54037,12 +51893,12 @@ fn aiur_fn_632( let __v_45: G = (__v_43 - __v_44); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); @@ -54050,7 +51906,7 @@ fn aiur_fn_632( let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(0); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; @@ -54060,7 +51916,6 @@ fn aiur_fn_632( let __v_62: G = __r_arr[0]; let __ret: [G; OUT_632] = [__v_62]; record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -54078,7 +51933,7 @@ fn aiur_fn_633( let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; @@ -54086,7 +51941,6 @@ fn aiur_fn_633( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_633] = [__v_6, __v_5]; record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -54111,19 +51965,17 @@ fn aiur_fn_634( match __v_2.as_canonical_u64() { 5u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_634] = [__v_8, __v_9]; record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_634] = [__v_1, __v_0]; record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54156,10 +52008,9 @@ fn aiur_fn_635( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_635] = [__v_13]; record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -54194,7 +52045,7 @@ fn aiur_fn_635( let __v_33: G = (__v_31 - __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -54204,18 +52055,18 @@ fn aiur_fn_635( let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); @@ -54223,10 +52074,9 @@ fn aiur_fn_635( let __v_56: G = (__v_7 + __v_55); let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_635] = [__v_58]; record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54257,10 +52107,9 @@ fn aiur_fn_636( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_636] = [__v_8]; record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -54269,10 +52118,9 @@ fn aiur_fn_636( let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_636] = [__v_9]; record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54301,7 +52149,6 @@ fn aiur_fn_637( 0u64 => { let __ret: [G; OUT_637] = [__v_0]; record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54310,17 +52157,16 @@ fn aiur_fn_637( let __v_7: G = (__v_2 - __v_6); let __v_8: G = (__v_7 - __v_3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_637] = [__v_16]; record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54352,7 +52198,6 @@ fn aiur_fn_638( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_638] = [__v_9]; record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54361,7 +52206,6 @@ fn aiur_fn_638( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_638] = [__v_7]; record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54386,7 +52230,6 @@ fn aiur_fn_639( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_639] = [__v_3, __v_4]; record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -54406,7 +52249,7 @@ fn aiur_fn_640( let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -54421,7 +52264,6 @@ fn aiur_fn_640( let __v_12: G = __r_arr[1]; let __ret: [G; OUT_640] = [__v_11, __v_12]; record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54441,7 +52283,6 @@ fn aiur_fn_640( let __v_19: G = __r_arr[1]; let __ret: [G; OUT_640] = [__v_18, __v_19]; record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54449,7 +52290,6 @@ fn aiur_fn_640( let __v_18: G = G::from_u64(0); let __ret: [G; OUT_640] = [__v_17, __v_18]; record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54486,7 +52326,6 @@ fn aiur_fn_641( let __v_12: G = G::from_u64(0); let __ret: [G; OUT_641] = [__v_11, __v_12]; record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -54511,7 +52350,6 @@ fn aiur_fn_641( let __v_14: G = G::from_u64(1); let __ret: [G; OUT_641] = [__v_14, __v_4]; record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54522,7 +52360,6 @@ fn aiur_fn_641( let __v_17: G = __r_arr[1]; let __ret: [G; OUT_641] = [__v_16, __v_17]; record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54556,7 +52393,6 @@ fn aiur_fn_642( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_642] = [__v_6]; record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -54569,7 +52405,6 @@ fn aiur_fn_642( let __v_9: G = G::from_u64(0); let __ret: [G; OUT_642] = [__v_9]; record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -54584,14 +52419,12 @@ fn aiur_fn_642( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_642] = [__v_12]; record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_642] = [__v_12]; record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54637,13 +52470,13 @@ fn aiur_fn_643( let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; match __v_12.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; @@ -54653,7 +52486,6 @@ fn aiur_fn_643( let __v_25: G = __r_arr[3]; let __ret: [G; OUT_643] = [__v_22, __v_23, __v_24, __v_25]; record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54666,7 +52498,6 @@ fn aiur_fn_643( let __v_21: G = __r_arr[3]; let __ret: [G; OUT_643] = [__v_18, __v_19, __v_20, __v_21]; record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54680,7 +52511,6 @@ fn aiur_fn_643( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_643] = [__v_11, __v_12, __v_13, __v_0]; record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54712,10 +52542,9 @@ fn aiur_fn_644( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_644] = [__v_12]; record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -54746,10 +52575,9 @@ fn aiur_fn_644( let __v_28: G = (__v_3 + __v_27); let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_644] = [__v_30]; record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54757,7 +52585,6 @@ fn aiur_fn_644( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_23]; record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54864,7 +52691,6 @@ fn aiur_fn_645( let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_645] = []; record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54917,7 +52743,6 @@ fn aiur_fn_646( } let __ret: [G; OUT_646] = []; record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -54944,25 +52769,23 @@ fn aiur_fn_647( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_647] = [__v_5]; record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_647] = [__v_10]; record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -54992,7 +52815,6 @@ fn aiur_fn_648( 1u64 => { let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -55003,7 +52825,6 @@ fn aiur_fn_648( let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55033,7 +52854,6 @@ fn aiur_fn_649( 0u64 => { let __ret: [G; OUT_649] = [__v_0, __v_2, __v_3]; record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55049,20 +52869,18 @@ fn aiur_fn_649( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __ret: [G; OUT_649] = [__v_14, __v_15, __v_16]; record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_649] = [__v_0, __v_2, __v_3]; record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55102,13 +52920,12 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -55118,18 +52935,17 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -55139,14 +52955,14 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); @@ -55155,11 +52971,10 @@ fn aiur_fn_650( } let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -55169,18 +52984,17 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -55188,14 +53002,13 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -55203,7 +53016,7 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; @@ -55212,7 +53025,6 @@ fn aiur_fn_650( let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -55220,7 +53032,7 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; @@ -55246,7 +53058,7 @@ fn aiur_fn_650( let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; @@ -55255,11 +53067,10 @@ fn aiur_fn_650( } let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55272,7 +53083,7 @@ fn aiur_fn_650( let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; @@ -55280,7 +53091,6 @@ fn aiur_fn_650( let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55319,7 +53129,6 @@ fn aiur_fn_651( let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_651] = []; record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -55361,11 +53170,10 @@ fn aiur_fn_652( let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_652] = [__v_24]; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -55374,10 +53182,9 @@ fn aiur_fn_652( let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_652] = [__v_22]; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -55389,7 +53196,6 @@ fn aiur_fn_652( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_21]; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -55401,7 +53207,6 @@ fn aiur_fn_652( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_21]; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -55413,7 +53218,6 @@ fn aiur_fn_652( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_21]; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -55429,16 +53233,14 @@ fn aiur_fn_652( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_23]; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_652] = [__v_21]; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55464,10 +53266,9 @@ fn aiur_fn_653( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_653] = [__v_6]; record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -55479,7 +53280,6 @@ fn aiur_fn_653( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_6]; record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55516,10 +53316,9 @@ fn aiur_fn_654( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_654] = [__v_14]; record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -55533,7 +53332,6 @@ fn aiur_fn_654( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_654] = [__v_14]; record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55597,10 +53395,9 @@ fn aiur_fn_655( 1u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_655] = [__v_39]; record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -55614,7 +53411,6 @@ fn aiur_fn_655( let __v_39: G = __r_arr[0]; let __ret: [G; OUT_655] = [__v_39]; record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55689,10 +53485,9 @@ fn aiur_fn_656( 1u64 => { let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_656] = [__v_50]; record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -55712,7 +53507,6 @@ fn aiur_fn_656( let __v_52: G = __r_arr[0]; let __ret: [G; OUT_656] = [__v_52]; record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55732,7 +53526,6 @@ fn aiur_fn_656( let __v_52: G = __r_arr[0]; let __ret: [G; OUT_656] = [__v_52]; record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55752,7 +53545,6 @@ fn aiur_fn_656( let __v_52: G = __r_arr[0]; let __ret: [G; OUT_656] = [__v_52]; record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55845,7 +53637,6 @@ fn aiur_fn_657( let __v_52: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_52]; record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55863,7 +53654,6 @@ fn aiur_fn_657( let __v_52: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_52]; record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55877,7 +53667,6 @@ fn aiur_fn_657( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_50]; record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55891,7 +53680,6 @@ fn aiur_fn_657( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_50]; record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55903,13 +53691,11 @@ fn aiur_fn_657( let __v_50: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_50]; record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_657] = [__v_48]; record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -55939,7 +53725,6 @@ fn aiur_fn_658( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_658] = [__v_5]; record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -55949,7 +53734,6 @@ fn aiur_fn_658( let __v_6: G = G::from_u64(1); let __ret: [G; OUT_658] = [__v_6]; record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -55957,7 +53741,6 @@ fn aiur_fn_658( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_658] = [__v_6]; record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -56085,7 +53868,6 @@ fn aiur_fn_659( let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_659] = []; record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -56113,7 +53895,6 @@ fn aiur_fn_660( 1u64 => { let __ret: [G; OUT_660] = []; record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -56134,7 +53915,6 @@ fn aiur_fn_660( let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_660] = []; record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56210,7 +53990,6 @@ fn aiur_fn_661( 1u64 => { let __ret: [G; OUT_661] = []; record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -56220,7 +53999,6 @@ fn aiur_fn_661( let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_661] = []; record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56308,7 +54086,6 @@ fn aiur_fn_662( let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_662] = []; record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -56326,17 +54103,16 @@ fn aiur_fn_663( let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_663] = [__v_8]; record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -56355,19 +54131,18 @@ fn aiur_fn_664( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_664] = [__v_10]; record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -56396,11 +54171,10 @@ fn aiur_fn_665( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_665] = [__v_5, __v_10, __v_4]; record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -56436,13 +54210,12 @@ fn aiur_fn_665( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_665] = [__v_35, __v_38, __v_2]; record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -56460,7 +54233,6 @@ fn aiur_fn_665( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_665] = [__v_9, __v_10, __v_8]; record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56690,7 +54462,6 @@ fn aiur_fn_666( } let __ret: [G; OUT_666] = [__v_49]; record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -56720,7 +54491,6 @@ fn aiur_fn_667( 1u64 => { let __ret: [G; OUT_667] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -56741,7 +54511,6 @@ fn aiur_fn_667( let __v_22: G = __r_arr[5]; let __ret: [G; OUT_667] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56773,7 +54542,6 @@ fn aiur_fn_668( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_668] = [__v_8]; record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -56808,7 +54576,6 @@ fn aiur_fn_669( 1u64 => { let __ret: [G; OUT_669] = []; record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -56932,7 +54699,6 @@ fn aiur_fn_669( let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_669] = []; record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -56975,7 +54741,6 @@ fn aiur_fn_670( 1u64 => { let __ret: [G; OUT_670] = []; record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -56996,7 +54761,6 @@ fn aiur_fn_670( let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_670] = []; record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57037,7 +54801,6 @@ fn aiur_fn_671( 1u64 => { let __ret: [G; OUT_671] = []; record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -57046,7 +54809,6 @@ fn aiur_fn_671( let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_671] = []; record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57075,7 +54837,7 @@ fn aiur_fn_672( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_0 [__v_6]; }, 0u64 => { @@ -57110,7 +54872,6 @@ fn aiur_fn_672( let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_672] = []; record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -57135,7 +54896,6 @@ fn aiur_fn_673( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_673] = [__v_3, __v_4, __v_2]; record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -57145,7 +54905,6 @@ fn aiur_fn_673( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_673] = [__v_5, __v_3, __v_4]; record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57173,7 +54932,6 @@ fn aiur_fn_674( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_674] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57190,7 +54948,6 @@ fn aiur_fn_674( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_674] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57215,7 +54972,6 @@ fn aiur_fn_675( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_675] = [__v_2, __v_3, __v_1]; record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57225,7 +54981,6 @@ fn aiur_fn_675( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_675] = [__v_4, __v_2, __v_3]; record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57250,7 +55005,6 @@ fn aiur_fn_676( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_676] = [__v_2, __v_3, __v_1]; record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57260,7 +55014,6 @@ fn aiur_fn_676( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_676] = [__v_4, __v_2, __v_3]; record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57285,7 +55038,6 @@ fn aiur_fn_677( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_677] = [__v_2, __v_3, __v_1]; record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57298,7 +55050,6 @@ fn aiur_fn_677( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -57306,7 +55057,6 @@ fn aiur_fn_677( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -57314,7 +55064,6 @@ fn aiur_fn_677( let __v_5: G = G::from_u64(2); let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57344,7 +55093,6 @@ fn aiur_fn_678( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_678] = [__v_2, __v_3, __v_1]; record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57357,7 +55105,6 @@ fn aiur_fn_678( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -57365,7 +55112,6 @@ fn aiur_fn_678( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -57373,7 +55119,6 @@ fn aiur_fn_678( let __v_5: G = G::from_u64(2); let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -57381,7 +55126,6 @@ fn aiur_fn_678( let __v_5: G = G::from_u64(3); let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57418,10 +55162,9 @@ fn aiur_fn_679( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_679] = [__v_12, __v_0]; record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57457,10 +55200,9 @@ fn aiur_fn_679( let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_679] = [__v_39, __v_37]; record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57485,7 +55227,6 @@ fn aiur_fn_680( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_680] = [__v_2, __v_3, __v_1]; record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57505,7 +55246,6 @@ fn aiur_fn_680( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_680] = [__v_13, __v_11, __v_12]; record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57596,7 +55336,6 @@ fn aiur_fn_681( let __v_63: G = __r_arr[2]; let __ret: [G; OUT_681] = [__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[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -57666,7 +55405,6 @@ fn aiur_fn_682( let __v_50: G = __r_arr[40]; let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -57696,10 +55434,9 @@ fn aiur_fn_683( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_683] = [__v_12, __v_0]; record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57766,10 +55503,9 @@ fn aiur_fn_683( let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); - let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_683] = [__v_70, __v_68]; record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57794,7 +55530,6 @@ fn aiur_fn_684( let __v_3: G = G::from_u64(1); let __ret: [G; OUT_684] = [__v_2, __v_3, __v_1]; record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -57814,7 +55549,6 @@ fn aiur_fn_684( let __v_13: G = G::from_u64(0); let __ret: [G; OUT_684] = [__v_13, __v_11, __v_12]; record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -57896,7 +55630,6 @@ fn aiur_fn_685( let __v_51: G = G::from_u64(0); let __ret: [G; OUT_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -57949,7 +55682,6 @@ fn aiur_fn_685( let __v_68: G = G::from_u64(0); let __ret: [G; OUT_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -58027,7 +55759,6 @@ fn aiur_fn_685( let __v_90: G = G::from_u64(2); let __ret: [G; OUT_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58116,7 +55847,6 @@ fn aiur_fn_686( let __v_64: G = __r_arr[54]; let __ret: [G; OUT_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -58146,10 +55876,9 @@ fn aiur_fn_687( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_687] = [__v_12, __v_0]; record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58230,10 +55959,9 @@ fn aiur_fn_687( let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); - let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_687] = [__v_84, __v_82]; record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -58315,7 +56043,6 @@ fn aiur_fn_688( let __v_51: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -58393,7 +56120,6 @@ fn aiur_fn_688( let __v_90: G = G::from_u64(1); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -58420,7 +56146,6 @@ fn aiur_fn_688( let __v_45: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -58447,7 +56172,6 @@ fn aiur_fn_688( let __v_45: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -58481,7 +56205,6 @@ fn aiur_fn_688( let __v_52: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -58504,7 +56227,6 @@ fn aiur_fn_688( let __v_42: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -58527,7 +56249,6 @@ fn aiur_fn_688( let __v_42: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -58550,7 +56271,6 @@ fn aiur_fn_688( let __v_42: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -58558,7 +56278,7 @@ fn aiur_fn_688( 0u64 => { let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; break '__mc_0 [__v_30, __v_11]; }, 1u64 => { @@ -58588,7 +56308,6 @@ fn aiur_fn_688( let __v_31: G = G::from_u64(0); let __ret: [G; OUT_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58630,14 +56349,13 @@ fn aiur_fn_689( let __v_18: G = __loaded[17]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_689] = [__v_23]; record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -58658,21 +56376,18 @@ fn aiur_fn_690( let __v_1: G = G::from_u64(0); let __ret: [G; OUT_690] = [__v_1]; record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_690] = [__v_1]; record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_690] = [__v_1]; record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58699,7 +56414,6 @@ fn aiur_fn_691( 1u64 => { let __ret: [G; OUT_691] = []; record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -58712,7 +56426,6 @@ fn aiur_fn_691( } let __ret: [G; OUT_691] = []; record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58739,7 +56452,6 @@ fn aiur_fn_692( 1u64 => { let __ret: [G; OUT_692] = []; record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -58752,7 +56464,6 @@ fn aiur_fn_692( } let __ret: [G; OUT_692] = []; record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58779,7 +56490,6 @@ fn aiur_fn_693( 1u64 => { let __ret: [G; OUT_693] = []; record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -58792,7 +56502,6 @@ fn aiur_fn_693( } let __ret: [G; OUT_693] = []; record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58819,7 +56528,6 @@ fn aiur_fn_694( 1u64 => { let __ret: [G; OUT_694] = []; record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -58828,7 +56536,6 @@ fn aiur_fn_694( } let __ret: [G; OUT_694] = []; record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58869,7 +56576,6 @@ fn aiur_fn_695( 1u64 => { let __ret: [G; OUT_695] = []; record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -58899,7 +56605,6 @@ fn aiur_fn_695( } let __ret: [G; OUT_695] = []; record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -58926,7 +56631,6 @@ fn aiur_fn_696( 1u64 => { let __ret: [G; OUT_696] = []; record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -59094,7 +56798,6 @@ fn aiur_fn_696( } let __ret: [G; OUT_696] = []; record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59121,7 +56824,6 @@ fn aiur_fn_697( 1u64 => { let __ret: [G; OUT_697] = []; record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -59291,7 +56993,6 @@ fn aiur_fn_697( } let __ret: [G; OUT_697] = []; record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59359,7 +57060,6 @@ fn aiur_fn_698( 1u64 => { let __ret: [G; OUT_698] = []; record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59448,7 +57148,6 @@ fn aiur_fn_698( let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_698] = []; record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -59484,7 +57183,6 @@ fn aiur_fn_699( 1u64 => { let __ret: [G; OUT_699] = []; record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -59499,7 +57197,6 @@ fn aiur_fn_699( let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_699] = []; record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59615,7 +57312,6 @@ fn aiur_fn_700( let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_700] = []; record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -59691,7 +57387,6 @@ fn aiur_fn_701( 1u64 => { let __ret: [G; OUT_701] = []; record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -59699,7 +57394,6 @@ fn aiur_fn_701( let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_701] = []; record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59726,14 +57420,12 @@ fn aiur_fn_702( 1u64 => { let __ret: [G; OUT_702] = []; record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_702] = []; record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -59865,7 +57557,6 @@ fn aiur_fn_703( let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -59888,7 +57579,6 @@ fn aiur_fn_703( let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -59914,7 +57604,6 @@ fn aiur_fn_703( let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60012,7 +57701,6 @@ fn aiur_fn_704( 1u64 => { let __ret: [G; OUT_704] = []; record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -60066,7 +57754,6 @@ fn aiur_fn_704( let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_704] = []; record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60205,7 +57892,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60231,7 +57917,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60251,7 +57936,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60271,7 +57955,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60291,7 +57974,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60310,7 +57992,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60329,7 +58010,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60348,7 +58028,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -60364,7 +58043,6 @@ fn aiur_fn_705( let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60403,7 +58081,6 @@ fn aiur_fn_706( } let __ret: [G; OUT_706] = []; record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -60497,7 +58174,6 @@ fn aiur_fn_707( let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_707] = []; record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -60518,7 +58194,6 @@ fn aiur_fn_707( let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_55, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_707] = []; record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60537,7 +58212,6 @@ fn aiur_fn_707( let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_55, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_707] = []; record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -60603,7 +58277,6 @@ fn aiur_fn_707( let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_55, __v_57, __v_58, __v_59, __v_60, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_707] = []; record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -60616,7 +58289,6 @@ fn aiur_fn_707( let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_55, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_707] = []; record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60671,7 +58343,6 @@ fn aiur_fn_708( let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_708] = []; record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -60699,13 +58370,11 @@ fn aiur_fn_709( 1u64 => { let __ret: [G; OUT_709] = [__v_2]; record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_709] = [__v_5]; record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60736,21 +58405,19 @@ fn aiur_fn_710( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_710] = [__v_9]; record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_710] = [__v_7]; record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60794,7 +58461,6 @@ fn aiur_fn_711( let __v_18: G = G::from_u64(0); let __ret: [G; OUT_711] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -60818,7 +58484,6 @@ fn aiur_fn_711( let __v_26: G = __r_arr[7]; let __ret: [G; OUT_711] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60849,17 +58514,15 @@ fn aiur_fn_712( 1u64 => { let __ret: [G; OUT_712] = [__v_1]; record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_712] = [__v_8]; record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60896,7 +58559,6 @@ fn aiur_fn_713( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_713] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -60920,7 +58582,6 @@ fn aiur_fn_713( let __v_19: G = __r_arr[7]; let __ret: [G; OUT_713] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60952,7 +58613,6 @@ fn aiur_fn_714( 1u64 => { let __ret: [G; OUT_714] = [__v_7]; record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -60977,7 +58637,6 @@ fn aiur_fn_714( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_714] = [__v_21]; record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60986,7 +58645,6 @@ fn aiur_fn_714( 0u64 => { let __ret: [G; OUT_714] = [__v_4]; record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -60994,7 +58652,6 @@ fn aiur_fn_714( let __v_22: G = __r_arr[0]; let __ret: [G; OUT_714] = [__v_22]; record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -61021,12 +58678,11 @@ fn aiur_fn_715( let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_715] = [__v_4]; record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -61051,17 +58707,15 @@ fn aiur_fn_716( 1u64 => { let __ret: [G; OUT_716] = [__v_1]; record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_716] = [__v_7]; record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61091,7 +58745,6 @@ fn aiur_fn_717( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_717] = [__v_4]; record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61101,7 +58754,6 @@ fn aiur_fn_717( let __v_6: G = (__v_4 + __v_5); let __ret: [G; OUT_717] = [__v_6]; record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61171,7 +58823,6 @@ fn aiur_fn_718( let __v_44: G = G::from_u64(0); let __ret: [G; OUT_718] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61195,7 +58846,6 @@ fn aiur_fn_718( let __v_52: G = __r_arr[7]; let __ret: [G; OUT_718] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61227,7 +58877,6 @@ fn aiur_fn_719( 0u64 => { let __ret: [G; OUT_719] = [__v_4]; record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61264,7 +58913,6 @@ fn aiur_fn_720( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_720] = [__v_11]; record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61274,7 +58922,6 @@ fn aiur_fn_720( let __v_13: G = (__v_11 + __v_12); let __ret: [G; OUT_720] = [__v_13]; record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61359,7 +59006,6 @@ fn aiur_fn_721( 1u64 => { let __ret: [G; OUT_721] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61420,7 +59066,6 @@ fn aiur_fn_721( let __v_109: G = __r_arr[44]; let __ret: [G; OUT_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61506,7 +59151,6 @@ fn aiur_fn_722( let __v_55: G = G::from_u64(0); let __ret: [G; OUT_722] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61530,7 +59174,6 @@ fn aiur_fn_722( let __v_63: G = __r_arr[7]; let __ret: [G; OUT_722] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61575,7 +59218,6 @@ fn aiur_fn_723( let __v_19: G = G::from_u64(0); let __ret: [G; OUT_723] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61599,7 +59241,6 @@ fn aiur_fn_723( let __v_27: G = __r_arr[7]; let __ret: [G; OUT_723] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61673,7 +59314,6 @@ fn aiur_fn_724( 1u64 => { let __ret: [G; OUT_724] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61723,7 +59363,6 @@ fn aiur_fn_724( let __v_87: G = __r_arr[33]; let __ret: [G; OUT_724] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61758,14 +59397,12 @@ fn aiur_fn_725( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_725] = [__v_4]; record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_725] = [__v_4]; record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61802,21 +59439,19 @@ fn aiur_fn_726( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_726] = [__v_15]; record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_726] = [__v_13]; record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61842,10 +59477,9 @@ fn aiur_fn_727( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_727] = [__v_4]; record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61860,10 +59494,9 @@ fn aiur_fn_727( let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_727] = [__v_9]; record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61891,7 +59524,6 @@ fn aiur_fn_728( 0u64 => { let __ret: [G; OUT_728] = [__v_0]; record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61907,7 +59539,6 @@ fn aiur_fn_728( 0u64 => { let __ret: [G; OUT_728] = [__v_7]; record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61941,7 +59572,6 @@ fn aiur_fn_729( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_729] = [__v_6]; record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -61951,7 +59581,6 @@ fn aiur_fn_729( let __v_8: G = (__v_6 + __v_7); let __ret: [G; OUT_729] = [__v_8]; record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -61992,7 +59621,6 @@ fn aiur_fn_730( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_730] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62037,21 +59665,19 @@ fn aiur_fn_731( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_731] = [__v_23]; record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_731] = [__v_21]; record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62084,7 +59710,6 @@ fn aiur_fn_732( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_732] = [__v_7]; record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -62094,7 +59719,6 @@ fn aiur_fn_732( let __v_9: G = (__v_7 + __v_8); let __ret: [G; OUT_732] = [__v_9]; record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62124,17 +59748,15 @@ fn aiur_fn_733( 1u64 => { let __ret: [G; OUT_733] = [__v_1]; record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_733] = [__v_7]; record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62168,13 +59790,12 @@ fn aiur_fn_734( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_734] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -62211,7 +59832,6 @@ fn aiur_fn_734( let __v_32: G = __r_arr[5]; let __ret: [G; OUT_734] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62219,11 +59839,10 @@ fn aiur_fn_734( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_734] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62243,7 +59862,6 @@ fn aiur_fn_734( let __v_33: G = __r_arr[5]; let __ret: [G; OUT_734] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62293,16 +59911,14 @@ fn aiur_fn_735( let __v_20: G = __r_arr[5]; let __ret: [G; OUT_735] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_735] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62352,14 +59968,13 @@ fn aiur_fn_736( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62378,14 +59993,13 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62408,14 +60022,13 @@ fn aiur_fn_736( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62434,24 +60047,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62459,11 +60070,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62486,24 +60096,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62511,11 +60119,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62525,11 +60132,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62537,11 +60143,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62568,14 +60173,13 @@ fn aiur_fn_736( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62594,24 +60198,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62619,11 +60221,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62646,24 +60247,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62671,11 +60270,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62685,11 +60283,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62697,11 +60294,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62726,14 +60322,13 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62756,14 +60351,13 @@ fn aiur_fn_736( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62782,24 +60376,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62807,11 +60399,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62834,24 +60425,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62859,11 +60448,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62873,11 +60461,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62885,11 +60472,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62916,14 +60502,13 @@ fn aiur_fn_736( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -62942,24 +60527,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62967,11 +60550,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -62994,24 +60576,22 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63019,11 +60599,10 @@ fn aiur_fn_736( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63033,11 +60612,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63045,11 +60623,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63078,14 +60655,13 @@ fn aiur_fn_736( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -63104,24 +60680,22 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63129,11 +60703,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63156,24 +60729,22 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63181,11 +60752,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63195,11 +60765,10 @@ fn aiur_fn_736( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63207,11 +60776,10 @@ fn aiur_fn_736( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63238,14 +60806,13 @@ fn aiur_fn_736( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -63264,24 +60831,22 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63289,11 +60854,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63316,24 +60880,22 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63341,11 +60903,10 @@ fn aiur_fn_736( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63355,11 +60916,10 @@ fn aiur_fn_736( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -63367,11 +60927,10 @@ fn aiur_fn_736( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 787376073..cc4c049b1 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -14,7 +14,7 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; -use aiur::execute::{ ExecError, IOBuffer, QueryRecord, record_budget_exceeded, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_add_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; +use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_add_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 3; const IN_0: usize = 3; @@ -33,10 +33,9 @@ fn aiur_fn_0( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_0] = [__v_5]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -49,10 +48,9 @@ fn aiur_fn_0( let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_0] = [__v_10]; record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -96,14 +94,12 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -112,7 +108,6 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -121,7 +116,6 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -130,7 +124,6 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -139,7 +132,6 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -148,7 +140,6 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -157,7 +148,6 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -166,7 +156,6 @@ fn aiur_fn_1( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_8]; record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -216,7 +205,6 @@ fn aiur_fn_2( let __v_23: G = __b2_add.1; let __ret: [G; OUT_2] = [__v_8, __v_12, __v_17, __v_22]; record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -245,7 +233,6 @@ fn aiur_fn_3( let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_3] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -266,7 +253,6 @@ fn aiur_fn_4( let __v_3: G = inp[3]; let __ret: [G; OUT_4] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -287,7 +273,6 @@ fn aiur_fn_5( let __v_3: G = inp[3]; let __ret: [G; OUT_5] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -318,7 +303,6 @@ fn aiur_fn_6( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_6] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -349,7 +333,6 @@ fn aiur_fn_7( let __v_11: G = (__v_8 + __v_6); let __ret: [G; OUT_7] = [__v_4, __v_10, __v_7, __v_11]; record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -398,7 +381,6 @@ fn aiur_fn_8( let __v_15: G = G::from_u64(0); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -413,7 +395,6 @@ fn aiur_fn_8( let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -429,7 +410,6 @@ fn aiur_fn_8( let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -444,7 +424,6 @@ fn aiur_fn_8( let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -458,7 +437,6 @@ fn aiur_fn_8( let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -471,7 +449,6 @@ fn aiur_fn_8( let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -483,7 +460,6 @@ fn aiur_fn_8( let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_8] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -494,7 +470,6 @@ fn aiur_fn_8( let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_8] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -504,7 +479,6 @@ fn aiur_fn_8( let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_8] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -553,7 +527,6 @@ fn aiur_fn_9( let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_9] = [__v_26]; record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -599,7 +572,6 @@ fn aiur_fn_10( let __v_28: G = (__v_0 + __v_27); let __ret: [G; OUT_10] = [__v_28]; record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -639,7 +611,6 @@ fn aiur_fn_11( let __v_22: G = (__v_18 - __v_21); let __ret: [G; OUT_11] = [__v_22]; record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -681,7 +652,6 @@ fn aiur_fn_12( } let __ret: [G; OUT_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -701,7 +671,6 @@ fn aiur_fn_13( let __v_2: G = (__v_0 + __v_1); let __ret: [G; OUT_13] = [__v_2]; record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -721,7 +690,6 @@ fn aiur_fn_14( let __v_2: G = (__v_0 * __v_1); let __ret: [G; OUT_14] = [__v_2]; record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -740,7 +708,6 @@ fn aiur_fn_15( let __v_1: G = (__v_0 * __v_0); let __ret: [G; OUT_15] = [__v_1]; record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -772,7 +739,6 @@ fn aiur_fn_16( } let __ret: [G; OUT_16] = [__v_1]; record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -795,7 +761,6 @@ fn aiur_fn_17( let __v_5: G = (__v_1 + __v_3); let __ret: [G; OUT_17] = [__v_4, __v_5]; record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -818,7 +783,6 @@ fn aiur_fn_18( let __v_5: G = (__v_1 - __v_3); let __ret: [G; OUT_18] = [__v_4, __v_5]; record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -841,7 +805,6 @@ fn aiur_fn_19( let __v_5: G = (__v_4 - __v_1); let __ret: [G; OUT_19] = [__v_3, __v_5]; record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -870,7 +833,6 @@ fn aiur_fn_20( let __v_11: G = (__v_9 + __v_10); let __ret: [G; OUT_20] = [__v_8, __v_11]; record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -912,7 +874,6 @@ fn aiur_fn_21( let __v_18: G = (__v_17 * __v_7); let __ret: [G; OUT_21] = [__v_15, __v_18]; record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -939,7 +900,6 @@ fn aiur_fn_22( let __v_7: G = __r_arr[1]; let __ret: [G; OUT_22] = [__v_6, __v_7]; record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -965,7 +925,6 @@ fn aiur_fn_23( let __v_8: G = (__v_5 * __v_7); let __ret: [G; OUT_23] = [__v_8]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -989,17 +948,15 @@ fn aiur_fn_24( 0u64 => { let __ret: [G; OUT_24] = [__v_2, __v_3]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_24] = [__v_4, __v_7]; record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1046,7 +1003,6 @@ fn aiur_fn_25( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_25] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1076,7 +1032,6 @@ fn aiur_fn_26( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_10, __v_9]; record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1099,7 +1054,6 @@ fn aiur_fn_27( let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_27] = [__v_2, __v_4]; record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1129,7 +1083,6 @@ fn aiur_fn_28( let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_28] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1159,7 +1112,6 @@ fn aiur_fn_29( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_10, __v_9]; record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1201,7 +1153,6 @@ fn aiur_fn_30( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_30] = [__v_19, __v_20, __v_18]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1259,7 +1210,6 @@ fn aiur_fn_31( let __v_36: G = __r_arr[8]; let __ret: [G; OUT_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1283,7 +1233,6 @@ fn aiur_fn_32( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_32] = [__v_3, __v_4]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1304,10 +1253,9 @@ fn aiur_fn_33( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_33] = [__v_4, __v_0]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1320,10 +1268,9 @@ fn aiur_fn_33( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_33] = [__v_9, __v_7]; record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1349,7 +1296,6 @@ fn aiur_fn_34( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1370,10 +1316,9 @@ fn aiur_fn_35( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_35] = [__v_4, __v_0]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1393,10 +1338,9 @@ fn aiur_fn_35( let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_35] = [__v_16, __v_14]; record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1422,7 +1366,6 @@ fn aiur_fn_36( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1443,10 +1386,9 @@ fn aiur_fn_37( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_37] = [__v_4, __v_0]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1460,10 +1402,9 @@ fn aiur_fn_37( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_37] = [__v_10, __v_8]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1489,7 +1430,6 @@ fn aiur_fn_38( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1510,10 +1450,9 @@ fn aiur_fn_39( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_39] = [__v_4, __v_0]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1557,10 +1496,9 @@ fn aiur_fn_39( let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_39] = [__v_40, __v_38]; record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1586,7 +1524,6 @@ fn aiur_fn_40( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1607,10 +1544,9 @@ fn aiur_fn_41( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_41] = [__v_4, __v_0]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1623,10 +1559,9 @@ fn aiur_fn_41( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_41] = [__v_9, __v_7]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1652,7 +1587,6 @@ fn aiur_fn_42( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1673,10 +1607,9 @@ fn aiur_fn_43( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_43] = [__v_4, __v_0]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1689,10 +1622,9 @@ fn aiur_fn_43( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_43] = [__v_9, __v_7]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1718,7 +1650,6 @@ fn aiur_fn_44( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1739,10 +1670,9 @@ fn aiur_fn_45( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_45] = [__v_4, __v_0]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1755,10 +1685,9 @@ fn aiur_fn_45( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_45] = [__v_9, __v_7]; record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1781,7 +1710,6 @@ fn aiur_fn_46( let __v_2: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_1, __v_2]; record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1805,7 +1733,6 @@ fn aiur_fn_47( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_47] = [__v_3, __v_4]; record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1826,10 +1753,9 @@ fn aiur_fn_48( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_48] = [__v_4, __v_0]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1842,10 +1768,9 @@ fn aiur_fn_48( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_48] = [__v_9, __v_7]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1874,7 +1799,6 @@ fn aiur_fn_49( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1898,7 +1822,6 @@ fn aiur_fn_50( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_50] = [__v_1, __v_3, __v_4]; record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1922,7 +1845,6 @@ fn aiur_fn_51( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_3, __v_4]; record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -1943,10 +1865,9 @@ fn aiur_fn_52( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_52] = [__v_4, __v_0]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -1960,10 +1881,9 @@ fn aiur_fn_52( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_52] = [__v_10, __v_8]; record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -1992,7 +1912,6 @@ fn aiur_fn_53( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2016,7 +1935,6 @@ fn aiur_fn_54( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_54] = [__v_3, __v_4]; record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2037,10 +1955,9 @@ fn aiur_fn_55( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_55] = [__v_4, __v_0]; record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2055,10 +1972,9 @@ fn aiur_fn_55( 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; 5] = [__v_10, __v_2, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 5] = [__v_10, __v_2, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_55] = [__v_11, __v_9]; record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2084,7 +2000,6 @@ fn aiur_fn_56( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_1, __v_3, __v_4]; record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2108,7 +2023,6 @@ fn aiur_fn_57( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_57] = [__v_3, __v_4]; record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2129,10 +2043,9 @@ fn aiur_fn_58( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_58] = [__v_4, __v_0]; record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2146,10 +2059,9 @@ fn aiur_fn_58( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_58] = [__v_10, __v_8]; record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2191,7 +2103,6 @@ fn aiur_fn_59( let __v_17: G = __r_arr[8]; let __ret: [G; OUT_59] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2216,7 +2127,6 @@ fn aiur_fn_60( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_60] = [__v_3, __v_4, __v_2]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2226,7 +2136,6 @@ fn aiur_fn_60( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_60] = [__v_5, __v_3, __v_4]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2287,7 +2196,6 @@ fn aiur_fn_61( let __v_32: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_1, __v_3, __v_4, __v_5, __v_7, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_24, __v_26, __v_27, __v_29, __v_31, __v_32]; record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2337,7 +2245,7 @@ fn aiur_fn_62( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); @@ -2348,11 +2256,11 @@ fn aiur_fn_62( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -2425,7 +2333,6 @@ fn aiur_fn_62( let __v_117: G = __r_arr[31]; let __ret: [G; OUT_62] = [__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]; record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -2514,7 +2421,6 @@ fn aiur_fn_63( let __v_69: G = G::from_u64(1); let __ret: [G; OUT_63] = [__v_67, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -2627,7 +2533,6 @@ fn aiur_fn_63( let __v_169: G = G::from_u64(1); let __ret: [G; OUT_63] = [__v_169, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -2714,10 +2619,9 @@ fn aiur_fn_63( let __v_246: G = G::from_u64(0); let __v_247: G = G::from_u64(0); let __v_248: G = G::from_u64(0); - let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_63] = [__v_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_248, __v_249, __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, __v_242, __v_243, __v_244, __v_245]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -2766,10 +2670,9 @@ fn aiur_fn_63( let __v_244: G = G::from_u64(0); let __v_245: G = G::from_u64(0); let __v_246: G = G::from_u64(0); - let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_63] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __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, __v_242, __v_243]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -2871,7 +2774,6 @@ fn aiur_fn_64( 1u64 => { let __ret: [G; OUT_64] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3016,12 +2918,11 @@ fn aiur_fn_64( let __v_201: G = __r_arr[31]; let __ret: [G; OUT_64] = [__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, __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]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_170: G = G::from_u64(0); - let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_170, __v_171, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; @@ -3057,7 +2958,6 @@ fn aiur_fn_64( let __v_203: G = __r_arr[31]; let __ret: [G; OUT_64] = [__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, __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]; record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3101,19 +3001,17 @@ fn aiur_fn_65( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_10]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_12]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3125,7 +3023,6 @@ fn aiur_fn_65( let __v_16: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_16]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -3534,7 +3431,6 @@ fn aiur_fn_66( 0u64 => { let __ret: [G; OUT_66] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -3875,20 +3771,18 @@ fn aiur_fn_67( 0u64 => { let __ret: [G; OUT_67] = [__v_0]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_7]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4086,16 +3980,14 @@ fn aiur_fn_68( let __v_154: G = __r_arr[29]; let __v_155: G = __r_arr[30]; let __v_156: G = __r_arr[31]; - let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_68] = [__v_157]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4103,7 +3995,6 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4111,7 +4002,6 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4119,7 +4009,6 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4127,7 +4016,6 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4135,7 +4023,6 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4143,7 +4030,6 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4151,7 +4037,6 @@ fn aiur_fn_68( _ => { let __ret: [G; OUT_68] = [__v_5]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4191,10 +4076,9 @@ fn aiur_fn_68( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_68] = [__v_42]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4362,10 +4246,9 @@ fn aiur_fn_68( let __v_161: G = __r_arr[29]; let __v_162: G = __r_arr[30]; let __v_163: G = __r_arr[31]; - let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_68] = [__v_164]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4583,10 +4466,10 @@ fn aiur_fn_69( let __v_189: G = __r_arr[29]; let __v_190: G = __r_arr[30]; let __v_191: G = __r_arr[31]; - let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_193: G = G::from_u64(1); let __v_194: G = G::from_u64(1); - let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_196: G = G::from_u64(0); let __v_197: G = G::from_u64(0); let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; @@ -4607,13 +4490,12 @@ fn aiur_fn_69( let __v_211: G = __r_arr[5]; let __v_212: G = __r_arr[6]; let __v_213: G = __r_arr[7]; - let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_216: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_216]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -4719,16 +4601,15 @@ fn aiur_fn_69( let __v_165: G = __r_arr[31]; let __v_166: G = G::from_u64(1); let __v_167: G = G::from_u64(1); - let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_169: G = G::from_u64(0); let __v_170: G = G::from_u64(1); let __v_171: G = (__v_2 + __v_170); - let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_173: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_173]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -4945,7 +4826,6 @@ fn aiur_fn_70( let __v_151: G = (__v_148 + __v_146); let __ret: [G; OUT_70] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -5226,7 +5106,6 @@ fn aiur_fn_71( let __v_255: G = __r_arr[15]; let __ret: [G; OUT_71] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __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[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6306,7 +6185,6 @@ fn aiur_fn_72( let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) }; let __ret: [G; OUT_72] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055]; record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6329,7 +6207,6 @@ fn aiur_fn_73( let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_73] = [__v_2, __v_4]; record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6356,7 +6233,6 @@ fn aiur_fn_74( let __v_8: G = (__v_0 + __v_7); let __ret: [G; OUT_74] = [__v_6, __v_8]; record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6389,7 +6265,6 @@ fn aiur_fn_75( let __v_14: G = (__v_0 + __v_13); let __ret: [G; OUT_75] = [__v_6, __v_2, __v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6428,7 +6303,6 @@ fn aiur_fn_76( let __v_20: G = (__v_0 + __v_19); let __ret: [G; OUT_76] = [__v_14, __v_2, __v_3, __v_4, __v_5, __v_15, __v_16, __v_17, __v_18, __v_20]; record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6458,7 +6332,6 @@ fn aiur_fn_77( let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_77] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6488,7 +6361,6 @@ fn aiur_fn_78( let __v_10: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_10, __v_9]; record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6546,7 +6418,6 @@ fn aiur_fn_79( let __v_36: G = __r_arr[8]; let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6567,10 +6438,9 @@ fn aiur_fn_80( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_80] = [__v_4, __v_0]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6614,10 +6484,9 @@ fn aiur_fn_80( let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_80] = [__v_40, __v_38]; record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6647,7 +6516,6 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -6658,7 +6526,6 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -6669,7 +6536,6 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -6677,7 +6543,6 @@ fn aiur_fn_81( let __v_4: G = G::from_u64(3); let __ret: [G; OUT_81] = [__v_3, __v_4, __v_4, __v_4, __v_2]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -6685,7 +6550,6 @@ fn aiur_fn_81( let __v_4: G = G::from_u64(4); let __ret: [G; OUT_81] = [__v_3, __v_4, __v_4, __v_4, __v_2]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { @@ -6693,7 +6557,6 @@ fn aiur_fn_81( let __v_4: G = G::from_u64(5); let __ret: [G; OUT_81] = [__v_3, __v_4, __v_4, __v_4, __v_2]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -6707,7 +6570,6 @@ fn aiur_fn_81( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_7, __v_3, __v_5, __v_8, __v_6]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -6721,7 +6583,6 @@ fn aiur_fn_81( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_7, __v_3, __v_5, __v_8, __v_6]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -6735,7 +6596,6 @@ fn aiur_fn_81( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_7, __v_3, __v_5, __v_8, __v_6]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -6746,7 +6606,6 @@ fn aiur_fn_81( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_3, __v_6, __v_6, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { @@ -6758,7 +6617,6 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { @@ -6770,7 +6628,6 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 12u64 => { @@ -6782,7 +6639,6 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { @@ -6794,7 +6650,6 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 14u64 => { @@ -6806,7 +6661,6 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6818,7 +6672,6 @@ fn aiur_fn_81( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_81] = [__v_5, __v_6, __v_7, __v_3, __v_4]; record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6841,10 +6694,9 @@ fn aiur_fn_82( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_82] = [__v_4, __v_0]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6860,10 +6712,9 @@ fn aiur_fn_82( let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_9]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_9]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_82] = [__v_12, __v_10]; record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6886,10 +6737,9 @@ fn aiur_fn_83( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_83] = [__v_4, __v_0]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6902,10 +6752,9 @@ fn aiur_fn_83( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_83] = [__v_9, __v_7]; record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -6934,7 +6783,6 @@ fn aiur_fn_84( let __v_6: G = __r_arr[1]; let __ret: [G; OUT_84] = [__v_1, __v_5, __v_6]; record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -6955,10 +6803,9 @@ fn aiur_fn_85( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_85] = [__v_4, __v_0]; record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -6972,10 +6819,9 @@ fn aiur_fn_85( 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; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_85] = [__v_10, __v_8]; record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7089,7 +6935,6 @@ fn aiur_fn_86( let __v_72: G = __r_arr[7]; let __ret: [G; OUT_86] = [__v_43, __v_41, __v_47, __v_31, __v_51, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __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_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_52]; record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7159,15 +7004,14 @@ fn aiur_fn_87( 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 = { let __values: [G; 10] = [__v_54, __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(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_56: G = { let __values: [G; 10] = [__v_53, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_55]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_57: G = { let __values: [G; 10] = [__v_52, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_58: G = { let __values: [G; 10] = [__v_51, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_57]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_59: G = { let __values: [G; 10] = [__v_50, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_58]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_60: G = { let __values: [G; 10] = [__v_49, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_59]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_55: G = { let __values: [G; 10] = [__v_54, __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(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 10] = [__v_53, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_55]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = { let __values: [G; 10] = [__v_52, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 10] = [__v_51, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_57]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 10] = [__v_50, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_58]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = { let __values: [G; 10] = [__v_49, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_59]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_87] = [__v_60]; record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7188,13 +7032,12 @@ fn aiur_fn_88( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 7] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 7] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_88] = [__v_4, __v_7, __v_0]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7260,12 +7103,11 @@ fn aiur_fn_88( let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 7] = [__v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_58]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_62: G = { let __values: [G; 7] = [__v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_58]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __ret: [G; OUT_88] = [__v_62, __v_63, __v_60]; record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7292,7 +7134,6 @@ fn aiur_fn_89( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_89] = [__v_3, __v_4, __v_2]; record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7305,7 +7146,6 @@ fn aiur_fn_89( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_89] = [__v_7, __v_5, __v_6]; record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7328,10 +7168,9 @@ fn aiur_fn_90( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_90] = [__v_4, __v_0]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7348,19 +7187,17 @@ fn aiur_fn_90( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_90] = [__v_11, __v_7]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_90] = [__v_10, __v_7]; record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7466,17 +7303,16 @@ fn aiur_fn_91( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_91] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70]; record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7525,12 +7361,11 @@ fn aiur_fn_92( let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 10] = [__v_28, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 10] = [__v_28, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_92] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_30, __v_20, __v_23, __v_24, __v_26, __v_27]; record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7554,13 +7389,12 @@ fn aiur_fn_93( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_93] = [__v_12]; record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7626,7 +7460,6 @@ fn aiur_fn_94( let __v_40: G = __r_arr[0]; let __ret: [G; OUT_94] = [__v_40]; record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7675,7 +7508,6 @@ fn aiur_fn_95( let __v_31: G = inp[31]; let __ret: [G; OUT_95] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -7698,7 +7530,6 @@ fn aiur_fn_96( 0u64 => { let __ret: [G; OUT_96] = [__v_3]; record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7709,12 +7540,11 @@ fn aiur_fn_96( let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0, __v_6, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_96] = [__v_11]; record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -7914,10 +7744,9 @@ fn aiur_fn_97( match __v_75.as_canonical_u64() { 1u64 => { let __v_172: G = G::from_u64(0); - let __v_173: G = { let __values: [G; 34] = [__v_172, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_173: G = { let __values: [G; 34] = [__v_172, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_97] = [__v_173]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7978,15 +7807,14 @@ fn aiur_fn_97( let __v_222: G = __r_arr[5]; let __v_223: G = __r_arr[6]; let __v_224: G = __r_arr[7]; - let __v_225: G = { let __values: [G; 8] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_226: G = { let __values: [G; 32] = [__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, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_225: G = { let __values: [G; 8] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_226: G = { let __values: [G; 32] = [__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, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_227: G = G::from_u64(0); - let __v_228: G = { let __values: [G; 34] = [__v_227, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_228: G = { let __values: [G; 34] = [__v_227, __v_6, __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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_205, __v_207, __v_208, __v_225, __v_226, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_229]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -7996,12 +7824,11 @@ fn aiur_fn_97( let __v_175: G = (__v_2 - __v_174); let __v_176: G = G::from_u64(1); let __v_177: G = (__v_3 + __v_176); - let __v_178: G = { let __values: [G; 32] = [__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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_178: G = { let __values: [G; 32] = [__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_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_173, __v_175, __v_177, __v_4, __v_178, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_179: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_179]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8178,16 +8005,14 @@ fn aiur_fn_97( let __v_153: G = __r_arr[29]; let __v_154: G = __r_arr[30]; let __v_155: G = __r_arr[31]; - let __v_156: G = { let __values: [G; 34] = [__v_17, __v_6, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_156: G = { let __values: [G; 34] = [__v_17, __v_6, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_97] = [__v_156]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8195,7 +8020,6 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8203,7 +8027,6 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8211,7 +8034,6 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8219,7 +8041,6 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8227,7 +8048,6 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8235,7 +8055,6 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8243,7 +8062,6 @@ fn aiur_fn_97( _ => { let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8251,7 +8069,7 @@ fn aiur_fn_97( _ => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0, __v_1, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(64); @@ -8416,10 +8234,9 @@ fn aiur_fn_97( let __v_165: G = __r_arr[29]; let __v_166: G = __r_arr[30]; let __v_167: G = __r_arr[31]; - let __v_168: G = { let __values: [G; 34] = [__v_95, __v_6, __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, __v_163, __v_164, __v_165, __v_166, __v_167]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_168: G = { let __values: [G; 34] = [__v_95, __v_6, __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, __v_163, __v_164, __v_165, __v_166, __v_167]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_97] = [__v_168]; record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -8482,11 +8299,11 @@ fn aiur_fn_98( 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; 8] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_45: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 8] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); - let __v_48: G = { let __values: [G; 34] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_48: G = { let __values: [G; 34] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_1, __v_2, __v_35, __v_44, __v_45, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -8559,7 +8376,6 @@ fn aiur_fn_98( let __v_115: G = __r_arr[31]; let __ret: [G; OUT_98] = [__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]; record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8748,7 +8564,6 @@ fn aiur_fn_99( let __v_169: G = __r_arr[31]; let __ret: [G; OUT_99] = [__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_169]; record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8856,7 +8671,6 @@ fn aiur_fn_100( let __v_82: G = (__v_67 * __v_81); let __ret: [G; OUT_100] = [__v_82]; record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -8973,7 +8787,6 @@ fn aiur_fn_101( let __v_96: G = __r_arr[31]; let __ret: [G; OUT_101] = [__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]; record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9012,7 +8825,6 @@ fn aiur_fn_101( let __v_96: G = __r_arr[31]; let __ret: [G; OUT_101] = [__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]; record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9040,7 +8852,6 @@ fn aiur_fn_102( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_102] = [__v_5]; record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9051,7 +8862,6 @@ fn aiur_fn_102( let __v_7: G = G::from_u64(1); let __ret: [G; OUT_102] = [__v_7]; record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9059,7 +8869,6 @@ fn aiur_fn_102( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_102] = [__v_7]; record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9092,10 +8901,9 @@ fn aiur_fn_103( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_103] = [__v_8]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9113,7 +8921,6 @@ fn aiur_fn_103( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_103] = [__v_11]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9134,17 +8941,15 @@ fn aiur_fn_103( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_103] = [__v_21]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_103] = [__v_23]; record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9202,7 +9007,6 @@ fn aiur_fn_104( let __v_21: G = G::from_u64(1); let __ret: [G; OUT_104] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_11, __v_1, __v_21]; record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -9223,7 +9027,6 @@ fn aiur_fn_104( let __v_23: G = G::from_u64(0); let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -9241,7 +9044,6 @@ fn aiur_fn_104( let __v_25: G = __r_arr[10]; let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9453,16 +9255,14 @@ fn aiur_fn_105( let __v_161: G = __r_arr[29]; let __v_162: G = __r_arr[30]; let __v_163: G = __r_arr[31]; - let __v_164: G = { let __values: [G; 34] = [__v_25, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_164: G = { let __values: [G; 34] = [__v_25, __v_5, __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, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_105] = [__v_164]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9470,7 +9270,6 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9478,7 +9277,6 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9486,7 +9284,6 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9494,7 +9291,6 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9502,7 +9298,6 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9510,7 +9305,6 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9518,7 +9312,6 @@ fn aiur_fn_105( _ => { let __ret: [G; OUT_105] = [__v_5]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9755,10 +9548,9 @@ fn aiur_fn_105( match __v_113.as_canonical_u64() { 1u64 => { let __v_209: G = G::from_u64(0); - let __v_210: G = { let __values: [G; 34] = [__v_209, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_210: G = { let __values: [G; 34] = [__v_209, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_105] = [__v_210]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -9815,26 +9607,24 @@ fn aiur_fn_105( let __v_255: G = __r_arr[5]; let __v_256: G = __r_arr[6]; let __v_257: G = __r_arr[7]; - let __v_258: G = { let __values: [G; 8] = [__v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_259: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_258: G = { let __values: [G; 8] = [__v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_259: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_260: G = G::from_u64(0); - let __v_261: G = { let __values: [G; 34] = [__v_260, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_261: G = { let __values: [G; 34] = [__v_260, __v_5, __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_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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_91, __v_92, __v_241, __v_258, __v_259, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_262]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_209: G = G::from_u64(1); let __v_210: G = (__v_2 + __v_209); - let __v_211: G = { let __values: [G; 32] = [__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_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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_211: G = { let __values: [G; 32] = [__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_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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_91, __v_92, __v_210, __v_3, __v_211, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_212: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_212]; record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -9890,7 +9680,7 @@ fn aiur_fn_106( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); @@ -9900,11 +9690,11 @@ fn aiur_fn_106( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -9977,7 +9767,6 @@ fn aiur_fn_106( let __v_116: G = __r_arr[31]; let __ret: [G; OUT_106] = [__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]; record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10065,7 +9854,6 @@ fn aiur_fn_107( let __v_67: G = __r_arr[31]; let __ret: [G; OUT_107] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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]; record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10121,7 +9909,6 @@ fn aiur_fn_108( 0u64 => { let __ret: [G; OUT_108] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10193,7 +9980,6 @@ fn aiur_fn_108( let __v_99: G = __r_arr[31]; let __ret: [G; OUT_108] = [__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]; record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10220,7 +10006,6 @@ fn aiur_fn_109( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_109] = [__v_4]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10231,7 +10016,6 @@ fn aiur_fn_109( let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_109] = [__v_7]; record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10329,7 +10113,6 @@ fn aiur_fn_110( let __v_71: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_71]; record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10443,7 +10226,6 @@ fn aiur_fn_110( let __v_172: G = __r_arr[32]; let __ret: [G; OUT_110] = [__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_169, __v_170, __v_171, __v_172]; record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10544,7 +10326,6 @@ fn aiur_fn_111( let __v_71: G = __r_arr[32]; let __ret: [G; OUT_111] = [__v_39, __v_40, __v_41, __v_42, __v_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]; record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10636,7 +10417,6 @@ fn aiur_fn_112( let __v_71: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_71]; record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10661,17 +10441,15 @@ fn aiur_fn_113( 1u64 => { let __ret: [G; OUT_113] = [__v_1]; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10702,7 +10480,6 @@ fn aiur_fn_114( let __v_5: G = G::from_u64(1); let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10714,7 +10491,6 @@ fn aiur_fn_114( 0u64 => { let __ret: [G; OUT_114] = [__v_6]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10722,7 +10498,6 @@ fn aiur_fn_114( let __v_7: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_7]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -10758,7 +10533,7 @@ fn aiur_fn_115( let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; @@ -10788,7 +10563,6 @@ fn aiur_fn_115( let __v_31: G = __r_arr[1]; let __ret: [G; OUT_115] = [__v_30, __v_31]; record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10810,7 +10584,7 @@ fn aiur_fn_116( let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; @@ -10819,7 +10593,6 @@ fn aiur_fn_116( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_116] = [__v_9]; record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -10850,10 +10623,9 @@ fn aiur_fn_117( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_117] = [__v_13]; record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10862,10 +10634,9 @@ fn aiur_fn_117( let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_117] = [__v_14]; record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10903,7 +10674,6 @@ fn aiur_fn_118( 1u64 => { let __ret: [G; OUT_118] = [__v_6, __v_7, __v_8, __v_9]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -10937,7 +10707,6 @@ fn aiur_fn_118( let __v_31: G = __r_arr[3]; let __ret: [G; OUT_118] = [__v_28, __v_29, __v_30, __v_31]; record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -10973,7 +10742,6 @@ fn aiur_fn_119( 1u64 => { let __ret: [G; OUT_119] = [__v_1]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11003,7 +10771,6 @@ fn aiur_fn_119( let __v_24: G = __r_arr[0]; let __ret: [G; OUT_119] = [__v_24]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11033,7 +10800,6 @@ fn aiur_fn_120( 1u64 => { let __ret: [G; OUT_120] = [__v_1]; record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11043,7 +10809,6 @@ fn aiur_fn_120( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_6]; record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11073,7 +10838,6 @@ fn aiur_fn_121( 1u64 => { let __ret: [G; OUT_121] = [__v_1]; record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11083,7 +10847,6 @@ fn aiur_fn_121( let __v_6: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_6]; record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11110,7 +10873,6 @@ fn aiur_fn_122( 0u64 => { let __ret: [G; OUT_122] = [__v_2]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -11118,7 +10880,6 @@ fn aiur_fn_122( let __v_3: G = __r_arr[0]; let __ret: [G; OUT_122] = [__v_3]; record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11148,7 +10909,6 @@ fn aiur_fn_123( 1u64 => { let __ret: [G; OUT_123] = [__v_0]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11166,7 +10926,6 @@ fn aiur_fn_123( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_14]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11200,10 +10959,9 @@ fn aiur_fn_124( 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_124] = [__v_0, __v_12]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11211,7 +10969,7 @@ fn aiur_fn_124( let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; @@ -11224,7 +10982,6 @@ fn aiur_fn_124( } let __ret: [G; OUT_124] = [__v_15, __v_16]; record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11253,10 +11010,9 @@ fn aiur_fn_125( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_125] = [__v_9, __v_0]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11305,10 +11061,9 @@ fn aiur_fn_125( let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_125] = [__v_43, __v_39]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11343,7 +11098,6 @@ fn aiur_fn_126( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_126] = [__v_5]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11357,7 +11111,6 @@ fn aiur_fn_126( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_126] = [__v_9]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11369,7 +11122,6 @@ fn aiur_fn_126( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_13]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11396,10 +11148,9 @@ fn aiur_fn_127( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_127] = [__v_6]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11414,7 +11165,6 @@ fn aiur_fn_127( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_8]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11427,10 +11177,9 @@ fn aiur_fn_127( let __v_12: G = (__v_3 - __v_11); let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_127] = [__v_14]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11469,10 +11218,9 @@ fn aiur_fn_128( 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_128] = [__v_17]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11488,20 +11236,18 @@ fn aiur_fn_128( let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 7] = [__v_21, __v_9, __v_19, __v_20, __v_17, __v_18, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_22: G = { let __values: [G; 7] = [__v_21, __v_9, __v_19, __v_20, __v_17, __v_18, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_128] = [__v_22]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_128] = [__v_19]; record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11540,7 +11286,6 @@ fn aiur_fn_129( let __v_9: G = G::from_u64(1); let __ret: [G; OUT_129] = [__v_9]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -11561,7 +11306,6 @@ fn aiur_fn_129( let __v_15: G = G::from_u64(1); let __ret: [G; OUT_129] = [__v_15]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11569,7 +11313,6 @@ fn aiur_fn_129( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_129] = [__v_11]; record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11600,14 +11343,12 @@ fn aiur_fn_130( let __v_2: G = G::from_u64(0); let __ret: [G; OUT_130] = [__v_2]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_130] = [__v_2]; record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11663,7 +11404,6 @@ fn aiur_fn_131( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_23]; record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11707,7 +11447,6 @@ fn aiur_fn_132( let __v_20: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_20]; record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -11739,7 +11478,6 @@ fn aiur_fn_133( 0u64 => { let __ret: [G; OUT_133] = [__v_0]; record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11762,7 +11500,6 @@ fn aiur_fn_133( let __v_23: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_23]; record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11796,7 +11533,6 @@ fn aiur_fn_134( 0u64 => { let __ret: [G; OUT_134] = [__v_0]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11822,7 +11558,6 @@ fn aiur_fn_134( let __v_25: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_25]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -11858,7 +11593,6 @@ fn aiur_fn_135( 0u64 => { let __ret: [G; OUT_135] = [__v_0]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11875,7 +11609,6 @@ fn aiur_fn_135( let __v_21: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_21]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -11900,7 +11633,6 @@ fn aiur_fn_135( let __v_29: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_29]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -11941,7 +11673,6 @@ fn aiur_fn_136( 0u64 => { let __ret: [G; OUT_136] = [__v_0]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -11981,7 +11712,6 @@ fn aiur_fn_136( let __v_32: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_32]; record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12011,10 +11741,9 @@ fn aiur_fn_137( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_137] = [__v_6]; record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12028,10 +11757,9 @@ fn aiur_fn_137( let __v_10: G = (__v_3 + __v_9); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_137] = [__v_12]; record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12058,7 +11786,6 @@ fn aiur_fn_138( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_138] = [__v_4]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12069,13 +11796,11 @@ fn aiur_fn_138( 0u64 => { let __ret: [G; OUT_138] = [__v_4]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_138] = [__v_2]; record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12106,10 +11831,9 @@ fn aiur_fn_139( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_139] = [__v_7]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12126,7 +11850,6 @@ fn aiur_fn_139( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_11]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -12140,10 +11863,9 @@ fn aiur_fn_139( let __v_13: G = (__v_4 + __v_12); let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_139] = [__v_15]; record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12174,13 +11896,11 @@ fn aiur_fn_140( 0u64 => { let __ret: [G; OUT_140] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_140] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12243,14 +11963,13 @@ fn aiur_fn_141( let __v_39: G = __r_arr[7]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_43: G = { let __values: [G; 10] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_44: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_45: G = { let __values: [G; 10] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_44]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_46: G = { let __values: [G; 10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 10] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 10] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_44]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_141] = [__v_46]; record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12283,7 +12002,6 @@ fn aiur_fn_142( 1u64 => { let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12305,13 +12023,11 @@ fn aiur_fn_142( let __v_21: G = __r_arr[1]; let __ret: [G; OUT_142] = [__v_20, __v_21, __v_12]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12366,7 +12082,6 @@ fn aiur_fn_143( } let __ret: [G; OUT_143] = [__v_0, __v_1]; record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12420,13 +12135,13 @@ fn aiur_fn_143( let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 3] = [__v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_50: G = { let __values: [G; 3] = [__v_46, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_46, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_19, __v_45, __v_50, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(1); @@ -12438,7 +12153,6 @@ fn aiur_fn_143( let __v_54: G = __r_arr[1]; let __ret: [G; OUT_143] = [__v_53, __v_54]; record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12640,7 +12354,6 @@ fn aiur_fn_144( let __v_95: G = G::from_u64(1); let __ret: [G; OUT_144] = [__v_95]; record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12705,7 +12418,6 @@ fn aiur_fn_145( let __v_29: G = G::from_u64(1); let __ret: [G; OUT_145] = [__v_29]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12719,7 +12431,6 @@ fn aiur_fn_145( let __v_33: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_33]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12776,7 +12487,7 @@ fn aiur_fn_146( let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(1); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_4, __v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; @@ -12789,7 +12500,7 @@ fn aiur_fn_146( let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; @@ -12818,7 +12529,7 @@ fn aiur_fn_146( let __v_64: G = __r_arr[1]; let __v_65: G = G::from_u64(1); let __v_66: G = G::from_u64(1); - let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_64, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; @@ -12855,7 +12566,6 @@ fn aiur_fn_146( let __v_84: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_84]; record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12879,7 +12589,6 @@ fn aiur_fn_147( let __v_4: G = (__v_2 * __v_3); let __ret: [G; OUT_147] = [__v_4]; record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -12905,7 +12614,6 @@ fn aiur_fn_148( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_148] = [__v_5]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -12920,7 +12628,6 @@ fn aiur_fn_148( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_9]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -12928,7 +12635,6 @@ fn aiur_fn_148( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_9]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -12967,17 +12673,16 @@ fn aiur_fn_149( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_24]; record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13035,7 +12740,6 @@ fn aiur_fn_150( let __v_36: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_36]; record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13091,7 +12795,6 @@ fn aiur_fn_151( 1u64 => { let __ret: [G; OUT_151] = [__v_1]; record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13101,7 +12804,6 @@ fn aiur_fn_151( let __v_37: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_37]; record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13131,7 +12833,6 @@ fn aiur_fn_152( 1u64 => { let __ret: [G; OUT_152] = [__v_1]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13148,7 +12849,6 @@ fn aiur_fn_152( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_152] = [__v_13]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13178,7 +12878,6 @@ fn aiur_fn_153( 0u64 => { let __ret: [G; OUT_153] = [__v_3, __v_0, __v_4]; record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -13217,12 +12916,12 @@ fn aiur_fn_153( let __v_36: G = __r_arr[31]; let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_44: 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_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -13233,7 +12932,6 @@ fn aiur_fn_153( 0u64 => { let __ret: [G; OUT_153] = [__v_46, __v_40, __v_47]; record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13294,7 +12992,6 @@ fn aiur_fn_154( let __v_25: G = __r_arr[2]; let __ret: [G; OUT_154] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_24, __v_25]; record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13328,7 +13025,6 @@ fn aiur_fn_155( 1u64 => { let __ret: [G; OUT_155] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13345,7 +13041,6 @@ fn aiur_fn_155( let __v_22: G = __r_arr[9]; let __ret: [G; OUT_155] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -13388,7 +13083,6 @@ fn aiur_fn_156( let __v_21: G = __r_arr[9]; let __ret: [G; OUT_156] = [__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[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13485,7 +13179,7 @@ fn aiur_fn_157( let __v_71: G = __b1_out[7]; let __v_72: G = G::from_u64(1); let __v_73: G = G::from_u64(1); - let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; @@ -13504,7 +13198,6 @@ fn aiur_fn_157( let __v_82: G = __r_arr[0]; let __ret: [G; OUT_157] = [__v_82]; record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13525,10 +13218,9 @@ fn aiur_fn_158( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_158] = [__v_4]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13543,10 +13235,9 @@ fn aiur_fn_158( let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_158] = [__v_9]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13588,7 +13279,6 @@ fn aiur_fn_159( let __v_14: G = __r_arr[0]; let __ret: [G; OUT_159] = [__v_14, __v_11, __v_12]; record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13614,14 +13304,13 @@ fn aiur_fn_160( let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_160] = [__v_13]; record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13640,14 +13329,13 @@ fn aiur_fn_161( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_161] = [__v_6]; record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13679,7 +13367,6 @@ fn aiur_fn_162( 1u64 => { let __ret: [G; OUT_162] = [__v_1]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13689,7 +13376,6 @@ fn aiur_fn_162( let __v_13: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_13]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13719,7 +13405,6 @@ fn aiur_fn_163( 1u64 => { let __ret: [G; OUT_163] = [__v_1]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -13740,7 +13425,6 @@ fn aiur_fn_163( let __v_15: G = __r_arr[0]; let __ret: [G; OUT_163] = [__v_15]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13777,7 +13461,6 @@ fn aiur_fn_164( let __v_11: G = __r_arr[0]; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13821,23 +13504,22 @@ fn aiur_fn_165( let __v_26: G = G::from_u64(118); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(48); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_165] = [__v_42]; record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -13858,16 +13540,14 @@ fn aiur_fn_166( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_166] = [__v_4]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_166] = [__v_1]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -13898,7 +13578,7 @@ fn aiur_fn_167( let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_6, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; @@ -13915,7 +13595,7 @@ fn aiur_fn_167( let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; @@ -13941,7 +13621,7 @@ fn aiur_fn_167( let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_41, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; @@ -13969,14 +13649,14 @@ fn aiur_fn_167( let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __v_67: G = G::from_u64(1); - let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_65, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); let __v_72: G = G::from_u64(1); - let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_70, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; @@ -14000,7 +13680,7 @@ fn aiur_fn_167( let __v_92: G = __r_arr[0]; let __v_93: G = G::from_u64(1); let __v_94: G = G::from_u64(1); - let __v_95: G = { let __values: [G; 3] = [__v_93, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_93, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_92, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; @@ -14038,7 +13718,6 @@ fn aiur_fn_167( let __v_121: G = __r_arr[0]; let __ret: [G; OUT_167] = [__v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_112]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14060,7 +13739,6 @@ fn aiur_fn_168( 0u64 => { let __ret: [G; OUT_168] = [__v_0, __v_1]; record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14074,7 +13752,6 @@ fn aiur_fn_168( let __v_8: G = __r_arr[1]; let __ret: [G; OUT_168] = [__v_7, __v_8]; record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14097,231 +13774,198 @@ fn aiur_fn_169( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(18446744069414584320); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(281474976710656); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(18446744069397807105); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(17293822564807737345); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(70368744161280); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(549755813888); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(17870292113338400769); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(13797081185216407910); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1803076106186727246); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(11353340290879379826); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(455906449640507599); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(17492915097719143606); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1532612707718625687); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16207902636198568418); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(17776499369601055404); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(6115771955107415310); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(12380578893860276750); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(9306717745644682924); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(18146160046829613826); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(3511170319078647661); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(17654865857378133588); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(5416168637041100469); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(16905767614792059275); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(9713644485405565297); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(5456943929260765144); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(17096174751763063430); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1213594585890690845); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(6414415596519834757); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(16116352524544190054); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(9123114210336311365); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(4614640910117430873); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_169] = [__v_1]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14351,7 +13995,6 @@ fn aiur_fn_170( let __v_8: G = __r_arr[1]; let __ret: [G; OUT_170] = [__v_7, __v_8]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14372,7 +14015,6 @@ fn aiur_fn_171( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_171] = [__v_1]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14384,7 +14026,6 @@ fn aiur_fn_171( let __v_5: G = (__v_1 * __v_4); let __ret: [G; OUT_171] = [__v_5]; record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14435,7 +14076,6 @@ fn aiur_fn_172( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_172] = [__v_11, __v_12, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14506,7 +14146,6 @@ fn aiur_fn_173( let __v_31: G = G::from_u64(1); let __ret: [G; OUT_173] = [__v_31]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14537,7 +14176,6 @@ fn aiur_fn_174( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_174] = [__v_8, __v_9]; record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14566,7 +14204,6 @@ fn aiur_fn_175( let __v_9: G = __r_arr[1]; let __ret: [G; OUT_175] = [__v_8, __v_9]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14591,10 +14228,9 @@ fn aiur_fn_176( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_7]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14611,10 +14247,9 @@ fn aiur_fn_176( let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_13]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14664,7 +14299,6 @@ fn aiur_fn_177( let __v_19: G = G::from_u64(0); let __ret: [G; OUT_177] = [__v_16, __v_19]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -14677,7 +14311,6 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -14686,7 +14319,6 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { @@ -14695,7 +14327,6 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { @@ -14704,7 +14335,6 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { @@ -14713,7 +14343,6 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14722,7 +14351,6 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -14733,25 +14361,21 @@ fn aiur_fn_177( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_19, __v_20]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_177] = [__v_9, __v_10]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_177] = [__v_11, __v_12]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_177] = [__v_13, __v_14]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { @@ -14766,7 +14390,6 @@ fn aiur_fn_177( let __v_24: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_23, __v_24]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { @@ -14781,7 +14404,6 @@ fn aiur_fn_177( let __v_24: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_23, __v_24]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { @@ -14796,7 +14418,6 @@ fn aiur_fn_177( let __v_24: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_23, __v_24]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { @@ -14808,7 +14429,6 @@ fn aiur_fn_177( let __v_22: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_21, __v_22]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14855,7 +14475,6 @@ fn aiur_fn_178( 1u64 => { let __ret: [G; OUT_178] = [__v_0, __v_1]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14870,7 +14489,6 @@ fn aiur_fn_178( let __v_27: G = __r_arr[1]; let __ret: [G; OUT_178] = [__v_26, __v_27]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -14923,7 +14541,6 @@ fn aiur_fn_179( let __v_23: G = __r_arr[1]; let __ret: [G; OUT_179] = [__v_16, __v_17, __v_22, __v_23]; record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -14969,7 +14586,6 @@ fn aiur_fn_180( let __v_25: G = G::from_u64(0); let __ret: [G; OUT_180] = [__v_22, __v_23, __v_24, __v_25]; record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -14991,7 +14607,6 @@ fn aiur_fn_180( let __v_33: G = __r_arr[1]; let __ret: [G; OUT_180] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15053,7 +14668,6 @@ fn aiur_fn_181( 1u64 => { let __ret: [G; OUT_181] = [__v_0, __v_1]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15152,7 +14766,6 @@ fn aiur_fn_181( let __v_79: G = __r_arr[1]; let __ret: [G; OUT_181] = [__v_78, __v_79]; record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15293,7 +14906,6 @@ fn aiur_fn_182( let __v_88: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_87, __v_88]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15305,7 +14917,6 @@ fn aiur_fn_182( let __v_68: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_67, __v_68]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15351,18 +14962,17 @@ fn aiur_fn_183( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; - let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_183] = [__v_34]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -15393,7 +15003,6 @@ fn aiur_fn_184( let __v_10: G = G::from_u64(0); let __ret: [G; OUT_184] = [__v_9, __v_10]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15411,7 +15020,6 @@ fn aiur_fn_184( let __v_16: G = __r_arr[1]; let __ret: [G; OUT_184] = [__v_15, __v_16]; record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15437,133 +15045,114 @@ fn aiur_fn_185( let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15588,13 +15177,12 @@ fn aiur_fn_186( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_186] = [__v_6, __v_9]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -15602,13 +15190,12 @@ fn aiur_fn_186( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_186] = [__v_6, __v_9]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 1u64 => { @@ -15622,7 +15209,6 @@ fn aiur_fn_186( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_186] = [__v_6, __v_8]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15680,7 +15266,6 @@ fn aiur_fn_187( let __v_27: G = G::from_u64(1); let __ret: [G; OUT_187] = [__v_27]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15774,7 +15359,6 @@ fn aiur_fn_187( let __v_80: G = __r_arr[0]; let __ret: [G; OUT_187] = [__v_80]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -15816,7 +15400,6 @@ fn aiur_fn_188( let __v_14: G = G::from_u64(0); let __ret: [G; OUT_188] = [__v_13, __v_14]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15834,7 +15417,6 @@ fn aiur_fn_188( let __v_20: G = __r_arr[1]; let __ret: [G; OUT_188] = [__v_19, __v_20]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -15869,7 +15451,6 @@ fn aiur_fn_189( 1u64 => { let __ret: [G; OUT_189] = [__v_0, __v_1]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -15890,7 +15471,6 @@ fn aiur_fn_189( let __v_19: G = __r_arr[1]; let __ret: [G; OUT_189] = [__v_18, __v_19]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16010,7 +15590,6 @@ fn aiur_fn_190( let __v_67: G = __r_arr[0]; let __ret: [G; OUT_190] = [__v_67]; record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16043,7 +15622,6 @@ fn aiur_fn_191( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_191] = [__v_4]; record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16058,7 +15636,6 @@ fn aiur_fn_191( let __v_8: G = __r_arr[0]; let __ret: [G; OUT_191] = [__v_8]; record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16092,10 +15669,9 @@ fn aiur_fn_192( 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 7] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 7] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_192] = [__v_11]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16111,17 +15687,15 @@ fn aiur_fn_192( let __v_12: G = __r_arr[0]; let __ret: [G; OUT_192] = [__v_12]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 7] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 7] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_192] = [__v_14]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16159,10 +15733,9 @@ fn aiur_fn_193( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_193] = [__v_8]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16178,17 +15751,15 @@ fn aiur_fn_193( let __v_9: G = __r_arr[0]; let __ret: [G; OUT_193] = [__v_9]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_193] = [__v_11]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16224,7 +15795,6 @@ fn aiur_fn_194( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_3, __v_4]; record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16245,10 +15815,9 @@ fn aiur_fn_195( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_195] = [__v_4, __v_0]; record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16261,10 +15830,9 @@ fn aiur_fn_195( let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_195] = [__v_9, __v_7]; record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16290,7 +15858,6 @@ fn aiur_fn_196( let __v_4: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_3, __v_4]; record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16311,10 +15878,9 @@ fn aiur_fn_197( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_197] = [__v_4, __v_0]; record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16334,10 +15900,9 @@ fn aiur_fn_197( let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_197] = [__v_16, __v_14]; record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, } @@ -16840,7 +16405,6 @@ fn aiur_fn_198( } let __ret: [G; OUT_198] = []; record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }) } @@ -16865,7 +16429,6 @@ fn aiur_fn_199( let __v_4: G = G::from_u64(0); let __ret: [G; OUT_199] = [__v_4]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -16875,7 +16438,6 @@ fn aiur_fn_199( let __v_6: G = (__v_4 + __v_5); let __ret: [G; OUT_199] = [__v_6]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16905,14 +16467,12 @@ fn aiur_fn_200( let __v_4: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_4]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_200] = [__v_4]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16945,7 +16505,6 @@ fn aiur_fn_201( 0u64 => { let __ret: [G; OUT_201] = [__v_4, __v_5]; record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -16989,7 +16548,6 @@ fn aiur_fn_202( let __v_18: G = G::from_u64(0); let __ret: [G; OUT_202] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -17013,7 +16571,6 @@ fn aiur_fn_202( let __v_26: G = __r_arr[7]; let __ret: [G; OUT_202] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17045,7 +16602,6 @@ fn aiur_fn_203( 0u64 => { let __ret: [G; OUT_203] = [__v_4]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17077,7 +16633,6 @@ fn aiur_fn_204( let __v_6: G = G::from_u64(0); let __ret: [G; OUT_204] = [__v_6]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -17087,7 +16642,6 @@ fn aiur_fn_204( let __v_8: G = (__v_6 + __v_7); let __ret: [G; OUT_204] = [__v_8]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17118,7 +16672,6 @@ fn aiur_fn_205( let __v_5: G = G::from_u64(0); let __ret: [G; OUT_205] = [__v_5]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -17128,7 +16681,6 @@ fn aiur_fn_205( let __v_7: G = (__v_5 + __v_6); let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17165,17 +16717,15 @@ fn aiur_fn_206( 1u64 => { let __ret: [G; OUT_206] = [__v_1]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_14]; record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17212,7 +16762,6 @@ fn aiur_fn_207( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -17236,7 +16785,6 @@ fn aiur_fn_207( let __v_19: G = __r_arr[7]; let __ret: [G; OUT_207] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17266,17 +16814,15 @@ fn aiur_fn_208( 1u64 => { let __ret: [G; OUT_208] = [__v_1]; record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_208] = [__v_7]; record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17302,7 +16848,6 @@ fn aiur_fn_209( 0u64 => { let __ret: [G; OUT_209] = [__v_0]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17318,7 +16863,6 @@ fn aiur_fn_209( 0u64 => { let __ret: [G; OUT_209] = [__v_7]; record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17354,7 +16898,6 @@ fn aiur_fn_210( let __v_8: G = G::from_u64(0); let __ret: [G; OUT_210] = [__v_8]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -17364,7 +16907,6 @@ fn aiur_fn_210( let __v_10: G = (__v_8 + __v_9); let __ret: [G; OUT_210] = [__v_10]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17401,7 +16943,6 @@ fn aiur_fn_211( let __v_11: G = G::from_u64(0); let __ret: [G; OUT_211] = [__v_11]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, 0u64 => { @@ -17411,7 +16952,6 @@ fn aiur_fn_211( let __v_13: G = (__v_11 + __v_12); let __ret: [G; OUT_211] = [__v_13]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17446,7 +16986,6 @@ fn aiur_fn_212( 0u64 => { let __ret: [G; OUT_212] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17509,7 +17048,6 @@ fn aiur_fn_213( 0u64 => { let __ret: [G; OUT_213] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17535,7 +17073,6 @@ fn aiur_fn_214( 0u64 => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17552,7 +17089,6 @@ fn aiur_fn_214( 0u64 => { let __ret: [G; OUT_214] = [__v_8]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17580,7 +17116,6 @@ fn aiur_fn_215( 0u64 => { let __ret: [G; OUT_215] = [__v_0]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17599,7 +17134,6 @@ fn aiur_fn_215( 0u64 => { let __ret: [G; OUT_215] = [__v_10]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17627,7 +17161,6 @@ fn aiur_fn_216( 0u64 => { let __ret: [G; OUT_216] = [__v_0]; record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { @@ -17674,7 +17207,6 @@ fn aiur_fn_216( 0u64 => { let __ret: [G; OUT_216] = [__v_38]; record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - if record_budget_exceeded() { return Err(ExecError::RecordBudgetExceeded); }; return Ok(__ret); }, _ => { From 05e8b8b154b7da7c7b62ba436dd3c6f18c7c075c Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Wed, 5 Aug 2026 16:14:17 +0000 Subject: [PATCH 10/20] aiur: analytic peak-prove-RAM model from circuit shapes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit AiurSystem::peak_prove_bytes(record): predicted peak prover RSS as the max of the schedule's three phase peaks — witness (QueryRecord + padded main traces + base-field lookup witness, all parallel-alive), stage-2 transition (stage-1 LDEs + tree + lookup witness + logUp messages with their batch-inverse copy + extension traces), and FRI open (all committed LDEs at 8·blowup bytes per cell + three Merkle trees + retained fold layers + open buffers) — plus preprocessed-gadget residency. Heights are next_power_of_two of the record's unique queries; widths, lookups, slot argument widths, and quotient degrees come from the compiled circuits; blowup and folding arity from the system parameters. Zero fitted constants. Mirrors multi-stark rev be1755e's allocation schedule. IX_AIUR_PRED_RAM=1 prints the prediction with per-phase breakdown at prove time. Validated against /usr/bin/time MaxRSS on five stratified Init shards (19.1-66.5 BFFT): residuals -0.4% to +3.0%, uniformly the expected allocator/decode-cache overhead above live bytes, and the open phase dominates in every case as the schedule analysis predicts. The empirical line needed a 25% usable-fraction absorber for its blind spots; this needs ~5%. --- crates/aiur/src/synthesis.rs | 103 +++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 085fa6d6f..5355aa27a 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -63,6 +63,16 @@ pub struct CircuitShape { pub preprocessed_height: usize, } +/// Per-phase breakdown from [`AiurSystem::peak_prove_bytes`]; `peak` is +/// the max phase plus the preprocessed residency. +pub struct PeakProveBytes { + pub phase_witness: usize, + pub phase_stage2: usize, + pub phase_open: usize, + pub preprocessed: usize, + pub peak: usize, +} + impl AiurSystem { pub fn build( toplevel: Toplevel, @@ -170,6 +180,85 @@ impl AiurSystem { .collect() } + /// Predicted peak prover resident bytes for a record, from circuit + /// shapes alone — the analytic counterpart of an empirical GiB-per-fft + /// line. Mirrors this system's actual allocation schedule (multi-stark + /// rev `be1755e`; the shard-pipeline E2E asserts prediction against a + /// measured prove, so a schedule change upstream turns a test red + /// instead of silently skewing every shard-RAM prediction): + /// + /// 1. WITNESS phase: the `QueryRecord` plus every circuit's padded main + /// trace and base-field lookup witness, built in parallel and all + /// alive at once (`prove`/`prove_ixvm` drop the record only after). + /// 2. STAGE-2 transition: stage-1 LDEs and their Merkle tree, the + /// still-alive lookup witness, the logUp message array plus its + /// batch-inverse copy, and the new extension traces. + /// 3. FRI OPEN: all committed LDEs (main + stage-2 + quotient, at + /// `8·2^log_blowup` bytes per trace cell) and their trees, the + /// retained FRI fold layers (geometric in `max_log_arity`), and the + /// open-phase buffers — all proportional to `H = blowup · tallest`. + /// + /// The peak is the max of the three plus the preprocessed-gadget + /// residency committed at setup. Heights are `next_power_of_two` of the + /// record's unique queries — the padding the trace actually commits, + /// which per-fft models blur. + pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes { + const S: usize = 8; // bytes per base field element (Goldilocks) + const DG: usize = 32; // blake3 digest bytes (Merkle nodes, arity 2) + let b = 1usize << self.commitment_parameters.log_blowup; + let fold = 1usize << self.fri_parameters.max_log_arity; + let mut witness = 0usize; + let mut s1_lde = 0usize; // stage-1 LDEs + let mut lookup_w = 0usize; // base-field lookup witness + let mut msgs = 0usize; // logUp messages (+ inverse copy) + let mut s2_trace = 0usize; // stage-2 extension traces + let mut committed = 0usize; // all committed LDE bytes + let mut prep = 0usize; + let mut tallest = 0usize; + for (i, ct) in self.circuit_types().iter().enumerate() { + let raw = match ct { + CircuitType::Function { idx } => record.function_queries[*idx].len(), + CircuitType::Memory { width } => { + record.memory_queries.get(width).map_or(0, |m| m.len()) + }, + CircuitType::Bytes1 => 256, + CircuitType::Bytes2 => 65536, + }; + if raw == 0 { + continue; + } + let n = raw.next_power_of_two(); + tallest = tallest.max(n); + let c = &self.system.circuits[i]; + let d = c.stage_2_width / (1 + c.num_lookups); // extension degree + let args: usize = self.slot_widths[i].iter().sum(); + let q = c.quotient_degree(); + witness += S * n * c.main_width + S * n * (c.num_lookups + args) + + 40 * raw; + s1_lde += S * b * n * c.main_width; + lookup_w += S * n * (c.num_lookups + args); + msgs += 2 * S * d * n * c.num_lookups; + s2_trace += S * n * c.stage_2_width; + committed += S * b * n * (c.main_width + c.stage_2_width + q * d); + prep += S * (1 + b) * c.preprocessed_width * c.preprocessed_height + + 2 * DG * b * c.preprocessed_height; + } + let h = b * tallest; + let record_bytes = crate::execute::record_retained_bytes(record); + let phase_witness = record_bytes + witness; + let phase_stage2 = s1_lde + 2 * DG * h + lookup_w + msgs + s2_trace; + // Trees (3 rounds) + retained FRI fold layers + open buffers, all ∝ H. + let fri_layers = (2 * S + 2 * DG) * h * fold / (fold - 1).max(1); + let phase_open = committed + 3 * 2 * DG * h + fri_layers + 11 * S * h; + PeakProveBytes { + phase_witness, + phase_stage2, + phase_open, + preprocessed: prep, + peak: phase_witness.max(phase_stage2).max(phase_open) + prep, + } + } + #[tracing::instrument(level = "info", skip_all, name = "aiur/prove")] pub fn prove( &self, @@ -263,6 +352,20 @@ impl AiurSystem { executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) .expect("IxVM-native Aiur execution failed during prove_ixvm"); drop(_g); + if std::env::var_os("IX_AIUR_PRED_RAM").is_some() { + const GIB: f64 = 1_073_741_824.0; + let p = self.peak_prove_bytes(&query_record); + let gib = |b: usize| crate::execute::f64_from_usize(b) / GIB; + eprintln!( + "[aiur] predicted peak prove RSS {:.2} GiB (witness {:.2} / \ + stage2 {:.2} / open {:.2} / preprocessed {:.2})", + gib(p.peak), + gib(p.phase_witness), + gib(p.phase_stage2), + gib(p.phase_open), + gib(p.preprocessed), + ); + } let _g = tracing::info_span!("aiur/witness").entered(); let circuit_types = self.circuit_types(); From e82f0474de30bcb9184717c745442d10e00fc59a Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Wed, 5 Aug 2026 20:36:14 +0000 Subject: [PATCH 11/20] scan: analytic RAM cut, cgroup process pool, width-first fast planning MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The scanner's cut and sidecar move from the fitted resource line to the analytic peak-prove-RSS model (AiurSystem::peak_prove_bytes) at budget x 0.95 x (1-eps), eps default 2% — the margin is the measured predicted-vs-MaxRSS residual (+0.6..+3.0% across six stratified proves on three envs), not a blind-spot absorber. Production STARK parameters consolidate in Protocol.lean (were triplicated across prove/verify); the scan FFI takes the compiled system and drops its per-call toplevel decode. Workers become 'ix shard-worker' child processes under user-delegated cgroup memory.max (oom.group=1), speaking a two-verb line protocol (SCAN in; SEG/SKIP/END out; a unit range degenerates to a single-block claim, so narrowing needs no verb). A worker that outgrows its cap is OOM-killed ALONE and recovered: respawn (fresh decode cache), retry once, then unit-narrow the dying batch; a block too dense for its slot's share retries on the BIG lane (whole-pool cap, serialized) and only a block that dies even there is named resource-infeasible in failed.csv. Fleet RAM is the sum of kernel-enforced caps, independent of content. Thread pool remains for in-process callers (tests). Sizing is width-first and uniform — full-core width, cap = measured pool / width, additive soft record cut below the cap (segments end gracefully at claim boundaries; the kill is reserved for mid-claim growth) — so planning wall time never depends on the prove budget: segments scan at RAM-optimal size and shards are assembled by the merge pass summing adjacent segments to the cut (sums are conservative for every cost in play: shared deps derive once, padded heights are subadditive). The refine re-measure pass is deleted with the coupling that motivated it. ix check --execute gains the same pool (execute-only whole-env check: no partition, record-drop segments, named rejects, measured totals). Jettisoned: the legacy Aiur counter-model packer (shard_esp_aiur, partition_for_aiur_ram, rebudget_manifest_shard + FFI/CLI/extern, -889 lines), fleet_plan and its planning constants, the blanket re-price. Surviving counter-model constants are profile-sweep advisory only and say so. Entry-overhead accounting corrected (13 -> 21 B: stored hash, multiplicity element, table slot); parent overhead is the measured post-schedule baseline instead of a guess. Validated: kill-recovery smoke (two live SIGKILLs mid-scan, 30000/30000 blocks covered, zero skips, cgroups cleaned); six-prove model validation ±2.3% worst; ixvm suite green throughout. ix prove --ixes batch mode replaces chunked --jobs barriers with RAM-aware admission: heaviest-first, the next shard's prove is admitted whenever the in-flight sum of sidecar pred_ram plus its own fits 0.92 x box; shards without predictions degrade to serial and --jobs remains as an optional ceiling. --- Ix/Aiur/Protocol.lean | 21 + Ix/Aiur/Semantics/BytecodeFfi.lean | 22 +- Ix/Cli/CheckCmd.lean | 4 +- Ix/Cli/ProveCmd.lean | 78 +- Ix/Cli/ShardCmd.lean | 100 ++- Ix/KernelCheck.lean | 19 +- Main.lean | 1 + Tests/Ix/Kernel/ShardPipeline.lean | 8 +- crates/aiur/src/execute.rs | 7 +- crates/aiur/src/synthesis.rs | 11 +- crates/ffi/src/aiur/scan.rs | 1185 ++++++++++++++++++++++------ crates/ffi/src/kernel.rs | 69 +- crates/kernel/src/shard.rs | 901 +-------------------- 13 files changed, 1124 insertions(+), 1302 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 705f2565f..40d61c4f8 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -104,6 +104,27 @@ opaque vkBytes : @& AiurSystem → ByteArray @[extern "rs_aiur_system_circuit_shapes"] opaque circuitShapes : @& AiurSystem → Array CircuitShape +/-- Scan-and-cut sharding against a Rust-owned `EnvHandle`, cutting on + the system's analytic peak-prove-RAM prediction (the system carries + the toplevel, so none is passed). Numeric params are decimal strings: + budget (GiB), eps (percent), workers (0 = autoscale), fail-fast ("0" + skips kernel-rejected blocks into a `.failed.csv`). Writes the `.ixes` + manifest and its costs sidecar to the output path. -/ +@[extern "rs_aiur_scan_shards_with_env"] +opaque scanShardsWithEnv : @& AiurSystem → + @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → @& String → + @& String → @& String → @& String → @& String → Except String Unit + +/-- The child side of the scan's process pool: run the stdin/stdout + worker loop until EOF (see `crates/ffi/src/aiur/scan.rs`, + `scan_worker`). Spawned by the parent scan as `ix shard-worker`; + numeric params are decimal strings: cut (GiB), batch blocks, soft + record cut (GiB), schedule pieces, exec-only ("1"/"0"). -/ +@[extern "rs_aiur_scan_worker"] +opaque scanWorker : @& AiurSystem → + @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → @& String → + @& String → @& String → Except String Unit + @[extern "rs_aiur_system_prove"] private opaque prove' : @& AiurSystem → @& Bytecode.FunIdx → @& Array G → diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 370be3379..22c8b8bf1 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -211,24 +211,6 @@ def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel) (shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode).map fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) -/-- Scan-and-cut sharding: execute the env's check schedule through the - codegen'd kernel as incrementally-grown thin-frontier `CheckEnv` - claims — the same claim type the prover pays for — with a running - FFT-cost readout, cutting shard boundaries where the measured cost - reaches the RAM budget's FFT equivalent (see - `crates/ffi/src/aiur/scan.rs`). Witness bytes fault in lazily, so a - scanner's RAM tracks one segment's touched set. Writes the `.ixes` - manifest plus a `.costs.csv` sidecar carrying the MEASURED per-shard - FFT mapped through the calibrated resource lines. Numeric params are - decimal strings (ABI-simple): budget GiB, cut headroom percent, - parallel chunk scanners (0 = autoscale), fail-fast ("0" skips - kernel-rejected blocks, recording them in a `.failed.csv` sidecar; - anything else aborts on the first). -/ -@[extern "rs_aiur_scan_shards_with_env"] -opaque scanShardsWithEnv : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → @& String → - @& String → @& String → Except String Unit - /-- Execute-only whole-env check through the codegen'd Aiur kernel: no partition, no manifest — the check verdict plus measured totals, reported on stderr. Args: workers (0 = autoscale), fail-fast ("0" @@ -236,8 +218,8 @@ opaque scanShardsWithEnv : @& Bytecode.Toplevel → the first). -/ @[extern "rs_aiur_execute_env_with_env"] opaque executeEnvWithEnv : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → - Except String Unit + @& Bytecode.FunIdx → @& EnvHandle → @& String → @& String → @& String → + @& String → Except String Unit end Bytecode.Toplevel diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 8573348a3..974a6b0a5 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -694,9 +694,11 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h let workers := (p.flag? "jobs").map (·.as! Nat) |>.getD 0 + let workerBin := (← IO.appPath).toString let start ← IO.monoMsNow match Aiur.Bytecode.Toplevel.executeEnvWithEnv compiled.bytecode funIdx - envHandle (toString workers) (if keepGoing then "0" else "1") with + envHandle (toString workers) (if keepGoing then "0" else "1") + workerBin ixe with | .error e => IO.eprintln s!"execute failed: {e}"; return 1 | .ok () => IO.println s!"execute: OK in {(← IO.monoMsNow) - start} ms" diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 23bed6d4f..2d4f282f0 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -263,23 +263,75 @@ def runShardProveAllNative (manifestPath : String) (envHandle : Aiur.EnvHandle) if (← Ix.Cli.VerifyCmd.verifyOneProof aiurSystem compiled proofAddr) != 0 then return .error s!"proof {proofAddr} failed verification" return .ok { shard := k, claimDigest := d, proofAddr } + -- RAM-aware admission — fastest wall without OOM: admit the next + -- (heaviest-first) shard whenever the predicted-RSS sum of in-flight + -- proves plus its own fits the box limit. Predictions come from the + -- scan sidecar's analytic per-shard `pred_ram_gib` (validated within + -- a few percent of measured RSS); a shard with no sidecar row is + -- assumed to need the whole limit, degrading to serial for exactly + -- those shards. `--jobs` remains as an optional concurrency ceiling. + let predRam : Std.HashMap Nat Nat ← do + let path : System.FilePath := ⟨manifestPath ++ ".costs.csv"⟩ + let mut m : Std.HashMap Nat Nat := {} + if ← path.pathExists then + for line in ((← IO.FS.readFile path).splitOn "\n").drop 1 do + let cols := line.splitOn "," + if cols.length ≥ 10 then + -- pred_ram_gib is column 8; integer GiB resolution suffices + -- for admission (the limit already carries an 8% margin). + match cols[0]!.toNat?, ((cols[8]!.splitOn ".")[0]!).toNat? with + | some k, some gib => m := m.insert k (gib + 1) + | _, _ => pure () + pure m + let boxGib : Nat ← do + let info ← IO.FS.readFile "/proc/meminfo" + match info.splitOn "\n" |>.head?.map (·.splitOn " " |>.filter (· ≠ "")) with + | some [_, kb, _] => pure ((kb.toNat?.getD 0) / (1024 * 1024)) + | _ => pure 0 + let limitGib := if boxGib == 0 then 0 else boxGib * 92 / 100 + let ramOf (k : Nat) : Nat := + (predRam.get? k).getD (if limitGib == 0 then 1 else limitGib) + IO.println s!"[prove] RAM-aware admission: box {boxGib} GiB, limit \ + {limitGib} GiB, {predRam.size} sidecar predictions" + let maxJobs := if jobs == 0 then shards.size else jobs let mut failures : List (Nat × String) := [] - for chunk in pending.toChunks (max 1 jobs) do - let tasks ← chunk.mapM fun k => - IO.asTask (prio := .dedicated) do pure (k, ← proveOneShard k) - for t in tasks do - match t.get with - | .ok (k, .ok row) => - recordProof row - done := done.insert k row.proofAddr - IO.println s!"[prove] shard {k}: proof {row.proofAddr} verified \ - ({done.size}/{shards.size})" - | .ok (k, .error e) => - IO.eprintln s!"[prove] shard {k} FAILED: {e}" - failures := (k, e) :: failures + let mut queue := pending + let mut running : List (Nat × Nat × Task (Except IO.Error (Nat × Except String ProofRow))) := [] + let mut inFlightGib : Nat := 0 + repeat + -- Admit while the next shard fits (always admit into an idle box). + while h : queue ≠ [] do + let k := queue.head h + let need := ramOf k + if running.isEmpty + || (running.length < maxJobs && inFlightGib + need ≤ limitGib) then + let t ← IO.asTask (prio := .dedicated) do pure (k, ← proveOneShard k) + running := (k, need, t) :: running + inFlightGib := inFlightGib + need + queue := queue.tail + else + break + -- Wait for any in-flight prove to finish, then retire it. + let fin ← match running.map (·.2.2) with + | [] => break + | t :: rest => IO.waitAny (t :: rest) + let (k, res) ← match fin with + | .ok kr => pure kr | .error e => IO.eprintln s!"[prove] task crashed: {e}" failures := (shards.size, toString e) :: failures + break + match res with + | .ok row => + recordProof row + done := done.insert k row.proofAddr + IO.println s!"[prove] shard {k}: proof {row.proofAddr} verified \ + ({done.size}/{shards.size})" + | .error e => + IO.eprintln s!"[prove] shard {k} FAILED: {e}" + failures := (k, e) :: failures + inFlightGib := inFlightGib - (running.find? (·.1 == k)).elim 0 (·.2.1) + running := running.filter (·.1 ≠ k) if !failures.isEmpty then IO.eprintln s!"[prove] {failures.length} shard(s) failed: \ {failures.map (·.1)}; re-run the same command to resume" diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index 131eea039..4284bee7a 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -14,9 +14,7 @@ the guest-cost packer runs on it (the profile is kept: re-tuning the budget is pure offline graph work on the `.ixprof`). - `.ixprof` input — the profile-driven packer directly (Zisk default; - the Aiur model packer stays reachable via `--backend aiur` for - `--rebudget`): + `.ixprof` input — the profile-driven packer directly (Zisk): - default / `--max-ram G` / `--max-cycles C`: **bin-pack to a per-shard cycle/RAM cap** — the fewest shards that each stay under the budget, each packed as full as the dependency structure allows (no `--max-ram` ⇒ sized to @@ -67,7 +65,7 @@ def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do let base := if ixePath.endsWith ".ixe" then (ixePath.dropEnd 4).toString else ixePath base ++ ".ixes" let budget := (p.flag? "max-ram").map (·.as! Nat) |>.getD 250 - let eps := (p.flag? "eps").map (·.as! Nat) |>.getD 5 + let eps := (p.flag? "eps").map (·.as! Nat) |>.getD 2 let workers := (p.flag? "workers").map (·.as! Nat) |>.getD 0 let noFailFast := p.hasFlag "no-fail-fast" if noFailFast && p.hasFlag "fail-fast" then @@ -99,9 +97,19 @@ def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do TracingTexray.startSampler TracingTexray.resetPeakTreeRss let start ← IO.monoMsNow - match Aiur.Bytecode.Toplevel.scanShardsWithEnv compiled.bytecode funIdx + -- The compiled system feeds the scanner's analytic peak-prove-RAM + -- model (circuit widths, lookup shapes, quotient degrees); its one-time + -- build cost (preprocessed gadget commit) is seconds against a + -- minutes-scale scan. + let system := Aiur.AiurSystem.build compiled.bytecode + Aiur.productionCommitmentParameters Aiur.productionFriParameters + -- Process-pool mode: the scan spawns ` shard-worker` + -- children under cgroup memory caps, so an over-cap worker is + -- OOM-killed alone and recovered, never the box. + let workerBin := (← IO.appPath).toString + match Aiur.AiurSystem.scanShardsWithEnv system funIdx envHandle (toString budget) (toString eps) (toString workers) - (if noFailFast then "0" else "1") outPath with + (if noFailFast then "0" else "1") outPath workerBin ixePath with | .ok () => if let some (out, rowName) := benchJson then let secs := ((← IO.monoMsNow) - start).toFloat / 1000.0 @@ -201,35 +209,16 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do if backend != "zisk" && backend != "aiur" then p.printError s!"error: --backend must be zisk or aiur (got {backend})" return 1 - - -- Surgical single-shard split: `--rebudget K --manifest M.ixes --max-ram G`. - -- Every other shard is copied verbatim (cached proofs stay valid); shard K - -- is replaced by children packed at the smaller budget. - match (p.flag? "rebudget").map (·.as! Nat) with - | some k => - let manifestIn := (p.flag? "manifest").map (·.as! String) |>.getD "" - if manifestIn.isEmpty then - p.printError "error: --rebudget needs --manifest (the input .ixes to split)" - return 1 - match maxRam with - | none => - p.printError "error: --rebudget needs --max-ram (per-child budget, GiB)" - return 1 - | some g => - IO.println s!"Rebudgeting shard {k} of {manifestIn} at {g} GiB per child" - rsShardRebudgetFFI espPath manifestIn (toString k) (toString g) - (toString balancePct) outPath - IO.println s!"[shard] wrote {outPath}" - return 0 - | none => pure () + -- Reaching here with `aiur` means a `.ixprof` input (a `.ixe` dispatched + -- to the scan above): the model packer that served it is gone. + if backend == "aiur" then + p.printError "error: the Aiur model packer was removed; run the measured scan on the .ixe instead" + return 1 -- Precedence: explicit --shards (fixed count) > explicit --max-cycles/--max-ram -- (budget) > default (size to detected system RAM). match shardsFlag with | some n => - if backend != "zisk" then - p.printError s!"error: --backend {backend} packs to a RAM budget; use --max-ram, not --shards" - return 1 IO.println s!"Sharding {espPath} into {n} shards (balance ±{balancePct}%)" rsShardEspFFI espPath (toString n) (toString balancePct) (toString parallelism) outPath @@ -244,6 +233,37 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do IO.println s!"[shard] wrote {outPath}" return 0 +/-- The child side of the scan's process pool: build the same + toplevel/system/env as the parent, then hand off to the Rust worker + loop (stdin commands, stdout replies) until EOF. -/ +def runShardWorkerCmd (p : Cli.Parsed) : IO UInt32 := do + let some ixe := (p.flag? "ixe").map (·.as! String) | do + p.printError "error: shard-worker requires --ixe" + return 1 + let cutGib := (p.flag? "cut-gib").map (·.as! String) |>.getD "inf" + let batch := (p.flag? "batch").map (·.as! Nat) |>.getD 128 + let softCap := (p.flag? "soft-cap-gib").map (·.as! String) |>.getD "inf" + let pieces := (p.flag? "pieces").map (·.as! Nat) |>.getD 16 + let toplevel ← match IxVM.ixVM with + | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 + | .ok t => pure t + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 + | .ok c => pure c + let funIdx ← match compiled.getFuncIdx `verify_claim with + | some i => pure i + | none => IO.eprintln "error: verify_claim missing"; return 1 + let system := Aiur.AiurSystem.build compiled.bytecode + Aiur.productionCommitmentParameters Aiur.productionFriParameters + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h + match Aiur.AiurSystem.scanWorker system funIdx envHandle cutGib + (toString batch) softCap (toString pieces) + (if p.hasFlag "exec-only" then "1" else "0") with + | .ok () => return 0 + | .error e => IO.eprintln s!"shard-worker: {e}"; return 1 + end Ix.Cli.ShardCmd open Ix.Cli.ShardCmd in @@ -253,9 +273,9 @@ def shardCmd : Cli.Cmd := `[Cli| FLAGS: "max-ram" : Nat; "Per-shard host-RAM budget, GiB (scan default 250; .ixprof default: detected system RAM)" - backend : String; "Planner: aiur (default on `.ixe`: measured scan) or zisk (`.ixe`: profile pass + guest-cost pack in one command; `.ixprof`: pack directly). On a `.ixprof`, `aiur` selects the model packer (--rebudget's path)" + backend : String; "Planner: aiur (default on `.ixe`: measured scan) or zisk (`.ixe`: profile pass + guest-cost pack in one command; `.ixprof`: pack directly)." out : String; "Output .ixes manifest path (default: input basename + .ixes)" - eps : Nat; "Scan only: pre-charged cut headroom, percent (default 5): covers the incremental claim-walk overcount and the merge pass's fft-sum conservatism" + eps : Nat; "Scan only: pre-charged cut headroom, percent (default 2): covers the batched claim readout's measured drift (~1%) plus merge-sum conservatism" workers : Nat; "Scan only: parallel chunk scanners (default 0 = autoscale to cores and detected RAM). Each holds one segment's query record and faulted witness, so workers × segment footprint must fit the box" "fail-fast"; "Scan: halt on the first kernel-rejected block (the default; flag accepted for explicitness)." "no-fail-fast"; "Scan: skip kernel-rejected blocks (named as skipped, excluded from the partition, listed in .failed.csv). The manifest then does not cover them — the downstream coverage gate reports exactly which." @@ -265,8 +285,6 @@ def shardCmd : Cli.Cmd := `[Cli| "max-cycles" : Nat; ".ixprof only: per-shard guest-cycle budget (overrides the RAM sizing)" balance : Nat; ".ixprof only: per-bisection balance tolerance, percent (default 5)" parallelism : Nat; ".ixprof only: provers assumed for the prove-time estimate (default 1 = sequential)" - rebudget : Nat; ".ixprof only: surgically split shard K of --manifest at the smaller --max-ram budget; every other shard is copied verbatim so its cached claims/proofs stay valid." - manifest : String; "Input .ixes manifest to split (with --rebudget)." ARGS: path : String; "A serialized `.ixe` env (measured scan) or a `.ixprof` from `ix profile` (profile packer)" @@ -275,4 +293,18 @@ def shardCmd : Cli.Cmd := `[Cli| shardExtractCmd ] +open Ix.Cli.ShardCmd in +def shardWorkerCmd : Cli.Cmd := `[Cli| + "shard-worker" VIA runShardWorkerCmd; + "INTERNAL: scan-worker child for the shard scanner's process pool — spawned automatically under a cgroup memory cap; not for direct use" + + FLAGS: + ixe : String; "Path to the `.ixe` env (same file as the parent scan)" + "cut-gib" : String; "Segment cut, GiB of predicted prove RSS (decimal string)" + batch : Nat; "Blocks per measurement claim" + "soft-cap-gib" : String; "Graceful record ceiling, GiB — segments cut here so only mid-claim growth reaches the cgroup kill" + pieces : Nat; "Schedule piece count (must match the parent's chunking)" + "exec-only"; "Execute-only mode: record-bytes cut, no prove model" +] + end diff --git a/Ix/KernelCheck.lean b/Ix/KernelCheck.lean index a24592416..fecb774c6 100644 --- a/Ix/KernelCheck.lean +++ b/Ix/KernelCheck.lean @@ -244,8 +244,8 @@ opaque rsShardEspFFI : `.ixes` manifest. `maxCycles` is a guest-STEP cap; if `ramGb` > 0 it is converted via the measured prover RAM model and overrides `maxCycles`. Pass "0" for whichever is unused. Decimal strings (ABI-simple). `backend` - selects the packing cost model: "zisk" (guest-STEP cap) or "aiur" (RAM - model; RAM budgets only). -/ + must be "zisk" (guest-STEP cap); "aiur" is rejected — Aiur shards via + the measured scan on the `.ixe`. -/ @[extern "rs_shard_esp_cap"] opaque rsShardEspCapFFI : @& String → -- .ixprof path @@ -257,21 +257,6 @@ opaque rsShardEspCapFFI : @& String → -- backend cost model (zisk|aiur) IO Unit -/-- FFI: surgically split ONE shard of an existing Aiur `.ixes` manifest at a - smaller per-shard RAM budget. Every other shard's block list is copied - verbatim (their claims and cached proofs stay valid); shard `k` is - replaced by its children (the first child keeps id `k`, the rest append - at the end). -/ -@[extern "rs_shard_rebudget"] -opaque rsShardRebudgetFFI : - @& String → -- .ixprof path - @& String → -- input .ixes manifest path - @& String → -- shard index to split - @& String → -- per-child RAM budget GiB - @& String → -- balance percent - @& String → -- output .ixes path - IO Unit - end Ix.KernelCheck end diff --git a/Main.lean b/Main.lean index af1bd2645..a7e76ec1f 100644 --- a/Main.lean +++ b/Main.lean @@ -48,6 +48,7 @@ def ixCmd : Cli.Cmd := `[Cli| profileCmd; proveCmd; shardCmd; + shardWorkerCmd; codegenCmd; verifyCmd; addrOfCmd; diff --git a/Tests/Ix/Kernel/ShardPipeline.lean b/Tests/Ix/Kernel/ShardPipeline.lean index ef73f6389..71131de63 100644 --- a/Tests/Ix/Kernel/ShardPipeline.lean +++ b/Tests/Ix/Kernel/ShardPipeline.lean @@ -97,8 +97,12 @@ def shardPipelineTests (env : Lean.Environment) let scanFunIdx ← match compiled.getFuncIdx `verify_claim with | some i => pure i | none => throw <| IO.userError "verify_claim missing" - match Aiur.Bytecode.Toplevel.scanShardsWithEnv compiled.bytecode scanFunIdx - envHandle "20" "5" "2" "1" scanIxes.toString with + let scanSystem := Aiur.AiurSystem.build compiled.bytecode + Aiur.productionCommitmentParameters Aiur.productionFriParameters + -- Empty worker-bin/ixe strings select the in-process thread pool: the + -- test binary cannot exec itself as `ix shard-worker`. + match Aiur.AiurSystem.scanShardsWithEnv scanSystem scanFunIdx + envHandle "20" "5" "2" "1" scanIxes.toString "" "" with | .error e => throw <| IO.userError s!"shard scan failed: {e}" | .ok () => pure () let (_, scanShards) ← diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 5d6de2347..acc9ebc2b 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -359,8 +359,9 @@ pub fn f64_from_usize(n: usize) -> f64 { } /// Approximate resident bytes of a [`QueryRecord`]: retained key/output -/// field elements (8 B each) plus ~13 B of per-entry index overhead -/// (stored hash, table slot, multiplicity). The memory-circuit stores +/// field elements (8 B each) plus ~21 B of per-entry index overhead +/// (stored hash 8, multiplicity element 8, hash-table slot ~5 with load +/// factor). The memory-circuit stores /// dominate on arithmetic-heavy content, where entries are FFT-cheap /// (narrow columns) but RAM-heavy — the second resource dimension a /// RAM-budgeted partition has to price alongside FFT cost. @@ -375,7 +376,7 @@ pub fn record_retained_bytes(record: &QueryRecord) -> usize { elems += m.retained_elems(); entries += m.len(); } - elems * 8 + entries * 13 + elems * 8 + entries * 21 } pub fn record_fft_cost(toplevel: &Toplevel, record: &QueryRecord) -> f64 { diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 5355aa27a..071ae4a6b 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -74,6 +74,13 @@ pub struct PeakProveBytes { } impl AiurSystem { + /// The bytecode this system was compiled from (drivers that execute + /// through the system — the shard scanner — read it here instead of + /// re-decoding their own copy). + pub fn toplevel(&self) -> &Toplevel { + &self.toplevel + } + pub fn build( toplevel: Toplevel, commitment_parameters: CommitmentParameters, @@ -233,8 +240,8 @@ impl AiurSystem { let d = c.stage_2_width / (1 + c.num_lookups); // extension degree let args: usize = self.slot_widths[i].iter().sum(); let q = c.quotient_degree(); - witness += S * n * c.main_width + S * n * (c.num_lookups + args) - + 40 * raw; + witness += + S * n * c.main_width + S * n * (c.num_lookups + args) + 40 * raw; s1_lde += S * b * n * c.main_width; lookup_w += S * n * (c.num_lookups + args); msgs += 2 * S * d * n * c.num_lookups; diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index f1668bebc..4b0d30310 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -1,12 +1,14 @@ //! Scan-and-cut sharding: shard boundaries from Aiur's own measured cost. //! //! Instead of predicting shard cost from profile counters, the env's check -//! schedule is EXECUTED through the codegen'd circuit kernel with a running -//! FFT-cost readout, and a shard boundary is cut where the measured cost -//! reaches the RAM budget's FFT equivalent. Execution is the mandatory -//! prefix of proving, so the measurement is the prove's own cost, not a -//! proxy — the failure mode where a recorder-side counter under-represents -//! circuit work by a content-dependent factor cannot occur. +//! schedule is EXECUTED through the codegen'd circuit kernel, and a shard +//! boundary is cut where the analytic peak-prove-RSS prediction computed +//! from the running record's circuit shapes +//! ([`AiurSystem::peak_prove_bytes`]) reaches the margined RAM budget. +//! Execution is the mandatory prefix of proving, so the measurement is the +//! prove's own cost, not a proxy — the failure mode where a recorder-side +//! counter under-represents circuit work by a content-dependent factor +//! cannot occur. //! //! The measurement unit is the SAME claim the prover pays for: a //! thin-frontier `CheckEnv`, one per BATCH of schedule blocks. Each @@ -57,12 +59,12 @@ use aiur::{ IOBuffer, QueryRecord, dump_query_stats, f64_from_usize, query_stats_enabled, record_fft_cost, record_retained_bytes, }, + synthesis::AiurSystem, }; use ix_common::address::Address; use ix_kernel::profile::{OpCounts, ProfileBuilder}; use ix_kernel::shard::{ - AIUR_RAM_BASE_GIB, AIUR_RAM_GIB_PER_BFFT, AIUR_RAM_USABLE_FRAC, ShardCost, - ShardInfo, ShardManifest, aiur_prove_secs_for_fft, aiur_ram_gib_for_fft, + ShardCost, ShardInfo, ShardManifest, aiur_prove_secs_for_fft, balanced_agg_tree, cost_fft, cut_coherent_order, }; use ixon::constant::ConstantInfo as IxonCI; @@ -75,12 +77,6 @@ use ixvm_codegen::aiur_ixvm_witness::{ /// Bytes per GiB. const GIB: f64 = 1_073_741_824.0; -/// Fraction of detected system RAM the worker fleet may plan against. -/// The fleet bound is arithmetic, not reactive: `workers × record cap` -/// is chosen under this line at startup, and the per-worker cap is -/// enforced inside execution, so measured RSS never depends on content. -const RAM_CEILING_FRAC: f64 = 0.70; - /// Current process resident set in GiB (`/proc/self/status` VmRSS); /// 0 where unreadable (non-Linux). Reported in segment logs. fn process_rss_gib() -> f64 { @@ -207,7 +203,7 @@ fn static_order( struct Segment { blocks: Vec, fft: f64, - bytes_gib: f64, + ram_gib: f64, } /// Everything a chunk scanner needs besides its own chunk: kernel, env, @@ -240,15 +236,19 @@ struct ScanCtx<'a> { /// frontier members), keeping the running readout tight enough to /// serve as the shard cost without a blanket re-price. batch_blocks: usize, - /// Execute-only mode: the cut charges RECORD BYTES alone against - /// `cut_used_gib` (a per-worker share of box RAM) — segments exist only - /// to drop records and keep the fleet resident — and no partition - /// semantics attach to the boundaries. RAM is bounded at claim - /// granularity only: a single claim's growth is uninstrumented by - /// design (Aiur execution carries no RAM tracking), so - /// pathologically dense content is bounded by worker count, not by - /// abort. - exec_only: bool, + /// The compiled system, feeding the analytic peak-prove-RAM model that + /// the scan's cut charges (`Some` for the scanner); `None` in + /// execute-only mode, where the cut is the record's retained bytes + /// against the per-worker share. + system: Option<&'a AiurSystem>, + /// Graceful record ceiling, GiB: a segment also cuts when its record's + /// retained bytes reach this, independent of the model cut. In + /// cgroup-capped worker processes it sits below the enforced cap + /// (~80%), so legitimately record-heavy segments end at a claim + /// boundary instead of being OOM-killed — the kill is reserved for + /// MID-claim growth, which no boundary check can see. `f64::INFINITY` + /// disables it (thread-pool mode). + soft_record_gib: f64, } /// Default blocks per measurement claim; `IX_SCAN_BATCH_BLOCKS` @@ -260,40 +260,10 @@ struct ScanCtx<'a> { /// manifest cost. const SCAN_BATCH_BLOCKS: usize = 128; -/// Smallest useful per-worker record share, GiB. Typical segments at any -/// realistic cut carry 3–8 GiB of record (measured 4–10% of the combined -/// cut across envs), so a share at this floor still lets normal segments -/// reach their cut untouched. -const MIN_WORKER_SHARE_GIB: f64 = 8.0; - -/// Joint worker-count / record-share arithmetic: the fleet plans against -/// `RAM_CEILING_FRAC × box − 10` (decode cache, witness maps, claim -/// trees), split evenly across workers. The share is a PLAN, not an -/// enforced cap — Aiur execution carries no RAM instrumentation, so a -/// worker's record is bounded only at claim boundaries (segments drop -/// records); pathologically dense single claims can exceed the share, -/// and the recourse is fewer workers (`--workers 1` plans the whole -/// allowance). `IX_SCAN_WORKER_SHARE_GIB` overrides for tests. Returns -/// `(workers, share_gib)`. -fn fleet_plan(workers: usize, cut_used_gib: f64) -> (usize, f64) { - let cores = std::thread::available_parallelism().map_or(4, usize::from); - let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - let usable = ram.mul_add(RAM_CEILING_FRAC, -10.0).max(MIN_WORKER_SHARE_GIB); - let workers = if workers == 0 { - let by_ram = format!("{:.0}", (usable / MIN_WORKER_SHARE_GIB).floor()) - .parse::() - .unwrap_or(1) - .max(1); - cores.saturating_sub(2).max(1).min(by_ram) - } else { - workers - }; - let share_gib = std::env::var("IX_SCAN_WORKER_SHARE_GIB") - .ok() - .and_then(|v| v.parse::().ok()) - .unwrap_or_else(|| (usable / f64_from_usize(workers)).min(cut_used_gib)); - (workers, share_gib) -} +/// A worker child's non-record residency: lazily-decoded env cache, +/// compiled system, runtime. Reserved under the cap so the soft cut +/// bounds the record and the cap only fires on mid-claim growth. +const WORKER_OVERHEAD_GIB: f64 = 4.0; /// The min-cut schedule order, truncated by the `IX_SCAN_LIMIT_BLOCKS` /// debug knob (a full-pipeline reproducer over a slice of a huge env, @@ -321,32 +291,32 @@ fn ordered_schedule( /// Equal-byte contiguous chunks over the order; edges are forced segment /// boundaries (the parallelism unit); the scan's merge pass repairs the /// resulting fragmentation, so chunk count is a pure parallelism knob. -fn make_chunks( +fn make_chunk_bounds( order: &[u32], blocks: &[SchedBlock], env_bytes: u64, n_chunks: usize, -) -> Vec> { +) -> Vec<(usize, usize)> { let per_chunk = (env_bytes / n_chunks as u64).max(1); - let mut chunks: Vec> = Vec::new(); - let mut cur: Vec = Vec::new(); + let mut bounds: Vec<(usize, usize)> = Vec::new(); + let mut start = 0usize; let mut acc = 0u64; - for &b in order { - cur.push(b); + for (i, &b) in order.iter().enumerate() { acc += blocks[b as usize].size; - if acc >= per_chunk && chunks.len() + 1 < n_chunks { - chunks.push(std::mem::take(&mut cur)); + if acc >= per_chunk && bounds.len() + 1 < n_chunks { + bounds.push((start, i + 1)); + start = i + 1; acc = 0; } } - if !cur.is_empty() { - chunks.push(cur); + if start < order.len() { + bounds.push((start, order.len())); } // Baseline before any execution: the schedule pass decoded every // constant into the shared env's lazy cache, so this RSS is (cache + // static structures) — the floor the worker footprints sit on. eprintln!("[scan] post-schedule baseline rss {:.0}G", process_rss_gib()); - chunks + bounds } /// Work-stealing worker pool over the chunks: workers pull `(origin @@ -436,6 +406,589 @@ fn run_pool( Ok(segments) } +/// The scan worker's stdin/stdout loop: a child process spawned by the +/// process pool, deterministically re-deriving the same schedule as its +/// parent and executing order-index ranges on command. Line protocol +/// (one command per stdin line, replies on stdout): +/// +/// - `SCAN ` — scan `order[lo..hi)` exactly like a thread +/// worker's range: up to [`RANGE_SEGMENTS`] segments, then hand the +/// remainder back. Replies: `SEG ` per +/// emitted segment (absolute order indices), `SKIP +/// ` per kernel-rejected block, then `END ` (`next == +/// hi` when the range is exhausted). A unit range (`hi == lo+1`) +/// degenerates to a single-block claim — the parent narrows a dying +/// batch by sending unit ranges, no dedicated verb needed. +/// +/// The worker never applies fail-fast itself — it reports SKIPs and the +/// parent enforces policy. RAM: the enclosing cgroup's `memory.max` is +/// the hard cap (an over-cap worker is OOM-killed and the parent +/// recovers); `soft_record_gib` cuts segments gracefully below it so +/// only MID-claim growth ever reaches the kill. +pub fn scan_worker( + system: &AiurSystem, + fun_idx: usize, + env: &Arc, + cut_used_gib: f64, + batch_blocks: usize, + soft_record_gib: f64, + pieces: usize, + exec_only: bool, +) -> Result<(), String> { + use std::io::{BufRead, Write}; + let toplevel = system.toplevel(); + let (blocks, adj) = schedule_blocks(env); + let order = ordered_schedule(&blocks, &adj, pieces); + let failed: Mutex> = Mutex::new(Vec::new()); + let abort = std::sync::atomic::AtomicBool::new(false); + let ctx = ScanCtx { + toplevel, + fun_idx, + env, + blocks: &blocks, + cut_used_gib, + n_chunks: pieces, + fail_fast: false, + failed: &failed, + abort: &abort, + batch_blocks, + system: if exec_only { None } else { Some(system) }, + soft_record_gib, + }; + let stdout = std::io::stdout(); + let mut out = stdout.lock(); + writeln!(out, "READY {}", order.len()).map_err(|e| e.to_string())?; + out.flush().map_err(|e| e.to_string())?; + let stdin = std::io::stdin(); + for line in stdin.lock().lines() { + let line = line.map_err(|e| e.to_string())?; + let mut it = line.split_whitespace(); + let (verb, lo, hi) = ( + it.next().unwrap_or(""), + it.next().and_then(|v| v.parse::().ok()), + it.next().and_then(|v| v.parse::().ok()), + ); + let (Some(lo), Some(hi)) = (lo, hi) else { + return Err(format!("worker: malformed command {line:?}")); + }; + if hi > order.len() || lo >= hi { + return Err(format!("worker: range {lo}..{hi} out of bounds")); + } + match verb { + "SCAN" => { + let range = &order[lo..hi]; + let (segs, rest) = + scan_range(&ctx, range, u32::try_from(lo).unwrap_or(0))?; + // Segments consume the range in order; skipped blocks sit in the + // gaps. Recover absolute bounds by cursor-matching first ids. + let mut cursor = lo; + for s in &segs { + while order[cursor] != s.blocks[0] { + cursor += 1; // a skipped block + } + let end = cursor + s.blocks.len(); + writeln!(out, "SEG {cursor} {end} {} {}", s.fft, s.ram_gib) + .map_err(|e| e.to_string())?; + cursor = end; + } + for (a, e) in failed.lock().unwrap().drain(..) { + writeln!(out, "SKIP {} {}", a.hex(), hex_encode(e.as_bytes())) + .map_err(|e| e.to_string())?; + } + writeln!(out, "END {}", hi - rest.len()).map_err(|e| e.to_string())?; + }, + _ => return Err(format!("worker: unknown verb {verb:?}")), + } + out.flush().map_err(|e| e.to_string())?; + } + Ok(()) +} + +fn hex_encode(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} + +fn hex_decode(s: &str) -> Option> { + if !s.len().is_multiple_of(2) { + return None; + } + (0..s.len() / 2) + .map(|i| u8::from_str_radix(&s[2 * i..2 * i + 2], 16).ok()) + .collect() +} + +/// Per-run cgroup-v2 management under the user-delegated subtree. Every +/// worker gets its own leaf with `memory.max` (the hard cap) and +/// `memory.oom.group=1` (an over-cap worker dies whole, never +/// half-alive). Best-effort: `None` anywhere means caps are unavailable +/// (no delegation) and the pool runs uncapped with a warning. +struct CgroupBase { + dir: std::path::PathBuf, +} + +impl CgroupBase { + fn create() -> Option { + let uid = std::fs::read_to_string("/proc/self/status") + .ok()? + .lines() + .find_map(|l| l.strip_prefix("Uid:"))? + .split_whitespace() + .next()? + .to_string(); + let dir = std::path::PathBuf::from(format!( + "/sys/fs/cgroup/user.slice/user-{uid}.slice/user@{uid}.service/ix-scan-{}", + std::process::id() + )); + std::fs::create_dir(&dir).ok()?; + Some(Self { dir }) + } + + fn child(&self, name: &str, cap_bytes: u64) -> Option { + let d = self.dir.join(name); + // A respawned worker reuses its slot's cgroup: tolerate the existing + // dir and rewrite the cap, so replacements stay capped. + match std::fs::create_dir(&d) { + Ok(()) => {}, + Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}, + Err(_) => return None, + } + std::fs::write(d.join("memory.max"), format!("{cap_bytes}")).ok()?; + // Best-effort: kill the whole worker on OOM, not one thread. + let _ = std::fs::write(d.join("memory.oom.group"), "1"); + Some(d) + } + + fn attach(dir: &std::path::Path, pid: u32) -> bool { + std::fs::write(dir.join("cgroup.procs"), format!("{pid}")).is_ok() + } +} + +impl Drop for CgroupBase { + fn drop(&mut self) { + if let Ok(entries) = std::fs::read_dir(&self.dir) { + for e in entries.flatten() { + let _ = std::fs::remove_dir(e.path()); + } + } + let _ = std::fs::remove_dir(&self.dir); + } +} + +/// Everything the process pool needs to spawn and command workers. +struct ProcPool<'a> { + bin: String, + ixe: String, + cut_used_gib: f64, + batch_blocks: usize, + soft_record_gib: f64, + pieces: usize, + exec_only: bool, + cap_bytes: u64, + /// The whole pool as a cap — the BIG lane for retrying blocks that + /// outgrow a slot's even share. Serialized by `big_lane`: at most one + /// big worker exists, so `Σ slot caps + pool_cap` bounds worst-case + /// fleet RAM only transiently and by design. + pool_cap_bytes: u64, + big_lane: Mutex<()>, + cgroups: Option, + order: &'a [u32], + blocks: &'a [SchedBlock], + fail_fast: bool, +} + +struct WorkerHandle { + child: std::process::Child, + stdin: std::process::ChildStdin, + stdout: std::io::BufReader, +} + +/// One `SCAN` round-trip's outcome. +struct ScanReply { + segs: Vec, + skips: Vec<(Address, String)>, + next: usize, +} + +impl ProcPool<'_> { + fn spawn(&self, slot: usize) -> Result { + self.spawn_capped(slot, self.cap_bytes, &format!("w{slot}")) + } + + fn spawn_capped( + &self, + slot: usize, + cap_bytes: u64, + cg_name: &str, + ) -> Result { + use std::process::{Command, Stdio}; + let mut cmd = Command::new(&self.bin); + cmd + .arg("shard-worker") + .args(["--ixe", &self.ixe]) + .args(["--cut-gib", &format!("{}", self.cut_used_gib)]) + .args(["--batch", &format!("{}", self.batch_blocks)]) + .args(["--soft-cap-gib", &format!("{}", self.soft_record_gib)]) + .args(["--pieces", &format!("{}", self.pieces)]) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()); + if self.exec_only { + cmd.arg("--exec-only"); + } + let mut child = cmd + .spawn() + .map_err(|e| format!("spawn worker {slot} ({}): {e}", self.bin))?; + if let Some(cg) = &self.cgroups { + match cg.child(cg_name, cap_bytes) { + Some(dir) if CgroupBase::attach(&dir, child.id()) => {}, + _ => { + eprintln!("[scan] worker {slot}: cgroup attach failed; UNCAPPED"); + }, + } + } + let stdin = child.stdin.take().expect("piped stdin"); + let stdout = + std::io::BufReader::new(child.stdout.take().expect("piped stdout")); + let mut h = WorkerHandle { child, stdin, stdout }; + // Verify the child derived the same schedule before trusting indices. + let ready = h.read_line()?; + let n: usize = ready + .strip_prefix("READY ") + .and_then(|v| v.trim().parse().ok()) + .ok_or_else(|| format!("worker {slot}: bad handshake {ready:?}"))?; + if n != self.order.len() { + return Err(format!( + "worker {slot}: schedule mismatch ({n} blocks vs {})", + self.order.len() + )); + } + Ok(h) + } + + /// Send one `SCAN` and collect its replies. `Err(committed)` = the + /// worker died mid-range; `committed` carries whatever segments and + /// skips arrived before death plus the index scanning had reached. + fn scan( + &self, + h: &mut WorkerHandle, + lo: usize, + hi: usize, + ) -> Result { + use std::io::Write; + let mut reply = ScanReply { segs: Vec::new(), skips: Vec::new(), next: lo }; + if writeln!(h.stdin, "SCAN {lo} {hi}").is_err() || h.stdin.flush().is_err() + { + return Err(reply); + } + loop { + let line = match h.read_line() { + Ok(l) => l, + Err(_) => return Err(reply), + }; + let mut it = line.split_whitespace(); + match it.next() { + Some("SEG") => { + let (Some(s), Some(e), Some(fft), Some(ram)) = ( + it.next().and_then(|v| v.parse::().ok()), + it.next().and_then(|v| v.parse::().ok()), + it.next().and_then(|v| v.parse::().ok()), + it.next().and_then(|v| v.parse::().ok()), + ) else { + return Err(reply); + }; + reply.segs.push(Segment { + blocks: self.order[s..e].to_vec(), + fft, + ram_gib: ram, + }); + reply.next = e; + }, + Some("SKIP") => { + let (Some(addr), Some(msg)) = ( + it.next().and_then(Address::from_hex), + it.next().and_then(hex_decode), + ) else { + return Err(reply); + }; + reply.skips.push((addr, String::from_utf8_lossy(&msg).into_owned())); + }, + Some("END") => { + let Some(next) = it.next().and_then(|v| v.parse::().ok()) + else { + return Err(reply); + }; + reply.next = next; + return Ok(reply); + }, + _ => return Err(reply), + } + } + } +} + +impl WorkerHandle { + fn read_line(&mut self) -> Result { + use std::io::BufRead; + let mut line = String::new(); + match self.stdout.read_line(&mut line) { + Ok(0) => Err("worker EOF".to_string()), + Ok(_) => Ok(line.trim_end().to_string()), + Err(e) => Err(e.to_string()), + } + } + + fn reap(mut self) -> String { + let _ = self.child.kill(); + match self.child.wait() { + Ok(st) => format!("{st}"), + Err(e) => format!("wait failed: {e}"), + } + } +} + +/// Process-pool scan: like [`run_pool`], but each worker is a separate +/// `ix shard-worker` process under a cgroup memory cap — a worker whose +/// record outgrows its cap mid-claim is OOM-killed ALONE, and the parent +/// recovers: retry the remainder once (transient collisions), then +/// narrow the dying batch with unit ranges to name the exact block as +/// resource-infeasible-at-cap and scan on. The fleet's RAM bound is +/// `Σ caps`, enforced by the kernel, independent of content. +fn run_pool_procs( + pool: &ProcPool<'_>, + chunks: Vec<(usize, usize)>, + workers: usize, + failed: &Mutex>, +) -> Result, String> { + type Range = (u32, u32, usize, usize); + let queue: Mutex> = Mutex::new( + chunks + .into_iter() + .enumerate() + .map(|(i, (lo, hi))| { + (u32::try_from(i).expect("chunk count fits u32"), 0u32, lo, hi) + }) + .collect(), + ); + let in_flight = AtomicUsize::new(0); + let done: Mutex)>> = Mutex::new(Vec::new()); + let failure: Mutex> = Mutex::new(None); + let abort = std::sync::atomic::AtomicBool::new(false); + std::thread::scope(|s| { + let (queue, in_flight, done, failure, abort) = + (&queue, &in_flight, &done, &failure, &abort); + for slot in 0..workers { + s.spawn(move || { + let mut worker = match pool.spawn(slot) { + Ok(w) => w, + Err(e) => { + let mut f = failure.lock().unwrap(); + if f.is_none() { + *f = Some(e); + } + abort.store(true, Ordering::Release); + return; + }, + }; + 'work: loop { + if abort.load(Ordering::Acquire) { + break; + } + let next = { + let mut q = queue.lock().unwrap(); + let popped = q.pop_front(); + if popped.is_some() { + in_flight.fetch_add(1, Ordering::AcqRel); + } + popped + }; + let Some((origin, seq, lo, hi)) = next else { + if in_flight.load(Ordering::Acquire) == 0 { + break; + } + std::thread::sleep(std::time::Duration::from_millis(50)); + continue; + }; + let mut cursor = lo; + let mut retried_at: Option = None; + let commit = + |reply: ScanReply, origin: u32, seq: u32| -> Result { + if !reply.segs.is_empty() { + done.lock().unwrap().push(((origin, seq), reply.segs)); + } + if !reply.skips.is_empty() { + let fatal = pool.fail_fast; + let first = reply.skips.first().cloned(); + failed.lock().unwrap().extend(reply.skips); + if fatal { + if let Some((a, e)) = first { + let mut f = failure.lock().unwrap(); + if f.is_none() { + *f = Some(format!( + "CheckEnv of block {} failed during scan: {e} \ + (--no-fail-fast records and skips such blocks)", + a.hex() + )); + } + } + return Err(()); + } + } + Ok(reply.next) + }; + while cursor < hi { + if abort.load(Ordering::Acquire) { + break 'work; + } + match pool.scan(&mut worker, cursor, hi) { + Ok(reply) => { + let Ok(next) = commit(reply, origin, seq) else { + abort.store(true, Ordering::Release); + break 'work; + }; + if next < hi { + queue.lock().unwrap().push_back((origin, seq + 1, next, hi)); + } + break; + }, + Err(partial) => { + let e = match commit(partial, origin, seq) { + Ok(n) => n, + Err(()) => { + abort.store(true, Ordering::Release); + break 'work; + }, + }; + let status = std::mem::replace( + &mut worker, + match pool.spawn(slot) { + Ok(w) => w, + Err(err) => { + let mut f = failure.lock().unwrap(); + if f.is_none() { + *f = Some(err); + } + abort.store(true, Ordering::Release); + break 'work; + }, + }, + ) + .reap(); + eprintln!( + "[scan] worker {slot} died ({status}) at index {e}; \ + respawned" + ); + if retried_at == Some(e) { + // Second death with zero progress: narrow one batch + // window with unit ranges to name the culprit. + let window = (e + pool.batch_blocks).min(hi); + let mut b = e; + while b < window { + match pool.scan(&mut worker, b, b + 1) { + Ok(reply) => { + if commit(reply, origin, seq).is_err() { + abort.store(true, Ordering::Release); + break 'work; + } + }, + Err(partial) => { + let _ = commit(partial, origin, seq); + let addr = + pool.blocks[pool.order[b] as usize].addr.clone(); + let status = std::mem::replace( + &mut worker, + match pool.spawn(slot) { + Ok(w) => w, + Err(err) => { + let mut f = failure.lock().unwrap(); + if f.is_none() { + *f = Some(err); + } + abort.store(true, Ordering::Release); + break 'work; + }, + }, + ) + .reap(); + // BIG-lane retry: one worker at a time gets the + // whole pool as its cap, so a block that is + // heavy-but-provable measures instead of being + // falsely excluded by its slot's even share. + let big_reply = { + let _lane = pool.big_lane.lock().unwrap(); + pool + .spawn_capped(slot, pool.pool_cap_bytes, "big") + .ok() + .map(|mut big| { + let r = pool.scan(&mut big, b, b + 1); + big.reap(); + r + }) + }; + match big_reply { + Some(Ok(reply)) => { + if commit(reply, origin, seq).is_err() { + abort.store(true, Ordering::Release); + break 'work; + } + eprintln!( + "[scan] block {} exceeded its slot cap \ + ({status}) but measured on the big lane", + addr.hex() + ); + }, + other => { + if let Some(Err(partial2)) = other { + let _ = commit(partial2, origin, seq); + } + eprintln!( + "[scan] block {} exceeded the worker memory \ + cap ({status}) and the big lane — \ + resource-infeasible; skipped", + addr.hex() + ); + failed.lock().unwrap().push(( + addr, + format!( + "record outgrew the {:.1} GiB whole-pool \ + cap mid-claim (cgroup OOM-kill)", + f64_from_usize( + usize::try_from(pool.pool_cap_bytes) + .unwrap_or(usize::MAX) + ) / GIB + ), + )); + }, + } + }, + } + b += 1; + } + cursor = window; + retried_at = None; + } else { + retried_at = Some(e); + cursor = e; + } + }, + } + } + in_flight.fetch_sub(1, Ordering::AcqRel); + } + worker.reap(); + }); + } + }); + if let Some(e) = failure.into_inner().unwrap() { + return Err(e); + } + let mut tagged = done.into_inner().unwrap(); + tagged.sort_by_key(|(k, _)| *k); + let mut segments: Vec = Vec::new(); + for (_, mut segs) in tagged { + segments.append(&mut segs); + } + Ok(segments) +} + /// Execute-only mode: run the whole env's check schedule through the /// codegen'd kernel in parallel — no partition, no manifest, no prove /// concerns. Segments exist only to drop records (cut when a worker's @@ -450,28 +1003,50 @@ pub fn execute_env( env: &Arc, workers: usize, fail_fast: bool, + proc_workers: Option<(&str, &str)>, ) -> Result { let (blocks, adj) = schedule_blocks(env); if blocks.is_empty() { return Err("empty environment".to_string()); } let env_bytes: u64 = blocks.iter().map(|b| b.size).sum(); - let (workers, share_gib) = fleet_plan(workers, f64::INFINITY); + let workers = if workers == 0 { + std::thread::available_parallelism() + .map_or(4, usize::from) + .saturating_sub(2) + .max(1) + } else { + workers + }; let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") .ok() .and_then(|v| v.parse::().ok()) .filter(|&k| k >= 1) .unwrap_or(SCAN_BATCH_BLOCKS); + // The schedule granularity is fixed by the core count so worker sizing + // cannot change the partition. + let sched_pieces = + (std::thread::available_parallelism().map_or(4, usize::from) * 2) + .min(blocks.len()) + .max(16); + let order = ordered_schedule(&blocks, &adj, sched_pieces); + let covered = order.len(); + // Post-schedule RSS: the parent's decode cache and static structures — + // the residency the worker fleet's record budget sits on top of. + let baseline_gib = process_rss_gib(); + let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); + // Thread-mode record drop: each worker's even share of the measured + // headroom — segments cut (and drop their record) when they reach it. + let record_cut_gib = (ram.mul_add(0.85, -baseline_gib - 2.0) + / f64_from_usize(workers)) + .clamp(4.0, 64.0); let n_chunks = (workers * 2).min(blocks.len()); eprintln!( - "[exec] {} blocks, {workers} workers over {n_chunks} chunks, \ - {share_gib:.1} GiB record share per worker (planned), {batch_blocks} \ - blocks per claim", + "[exec] {} blocks, {workers} workers over {n_chunks} chunks, record \ + drop at {record_cut_gib:.1} GiB, {batch_blocks} blocks per claim", blocks.len() ); - let order = ordered_schedule(&blocks, &adj, n_chunks); - let covered = order.len(); - let chunks = make_chunks(&order, &blocks, env_bytes, n_chunks); + let bounds = make_chunk_bounds(&order, &blocks, env_bytes, n_chunks); let failed: Mutex> = Mutex::new(Vec::new()); let abort = std::sync::atomic::AtomicBool::new(false); let ctx = ScanCtx { @@ -479,15 +1054,64 @@ pub fn execute_env( fun_idx, env, blocks: &blocks, - cut_used_gib: share_gib, - n_chunks: chunks.len(), + cut_used_gib: record_cut_gib, + n_chunks: bounds.len(), fail_fast, failed: &failed, abort: &abort, batch_blocks, - exec_only: true, + system: None, + soft_record_gib: f64::INFINITY, + }; + let segments = match proc_workers { + Some((bin, ixe)) => { + // Fastest wall without OOM: execution has no prove-cut constraint + // on segment size, so width goes to the core count and the cap is + // whatever the pool affords per worker — smaller segments cost + // only a few percent of cold-boundary work. + let pool_gib = ram.mul_add(0.85, -baseline_gib - 2.0).max(8.0); + let cap_gib = (pool_gib / f64_from_usize(workers)).clamp(6.0, 64.0); + let soft_gib = (cap_gib - WORKER_OVERHEAD_GIB).max(cap_gib / 2.0); + let cgroups = CgroupBase::create(); + if cgroups.is_none() { + eprintln!( + "[exec] cgroup delegation unavailable — workers run UNCAPPED" + ); + } + eprintln!( + "[exec] process pool: {workers} workers, {cap_gib:.1} GiB cap \ + each{}", + if cgroups.is_some() { " (cgroup memory.max)" } else { "" } + ); + let pool = ProcPool { + bin: bin.to_string(), + ixe: ixe.to_string(), + cut_used_gib: soft_gib, + batch_blocks, + soft_record_gib: soft_gib, + pieces: sched_pieces, + exec_only: true, + cap_bytes: gib_to_bytes_u64(cap_gib), + pool_cap_bytes: gib_to_bytes_u64( + crate::kernel::system_ram_gib() + .unwrap_or(64.0) + .mul_add(0.85, -baseline_gib - 2.0) + .max(8.0), + ), + big_lane: Mutex::new(()), + cgroups, + order: &order, + blocks: &blocks, + fail_fast, + }; + run_pool_procs(&pool, bounds, workers, &failed)? + }, + None => { + let chunks = + bounds.iter().map(|&(lo, hi)| order[lo..hi].to_vec()).collect(); + run_pool(&ctx, chunks, workers)? + }, }; - let segments = run_pool(&ctx, chunks, workers)?; let total_fft: f64 = segments.iter().map(|s| s.fft).sum(); let checked: usize = segments.iter().map(|s| s.blocks.len()).sum(); let failed = failed.into_inner().unwrap(); @@ -512,8 +1136,21 @@ pub fn execute_env( /// Scan-and-cut over the whole env: returns the manifest report, writing /// the manifest and its costs sidecar to `out_path`. #[allow(clippy::too_many_arguments)] +/// The predicted-vs-measured margin the cut leaves under the budget: +/// the analytic model predicts live bytes, and measured MaxRSS runs a +/// few percent above (allocator slack, the prove process's own env +/// decode cache, OS overhead) — validated at +3.0% worst across a +/// stratified Init prove sample. 0.95 covers it with room. +const PROVE_RAM_MARGIN: f64 = 0.95; + +/// GiB → whole bytes via the decimal round-trip (no `as` cast); caps are +/// small positive magnitudes. +fn gib_to_bytes_u64(gib: f64) -> u64 { + format!("{:.0}", (gib * GIB).max(0.0)).parse().unwrap_or(u64::MAX) +} + pub fn scan_shards( - toplevel: &Toplevel, + system: &AiurSystem, fun_idx: usize, env: &Arc, budget_gib: f64, @@ -521,43 +1158,72 @@ pub fn scan_shards( workers: usize, fail_fast: bool, out_path: &str, + proc_workers: Option<(&str, &str)>, ) -> Result { - let cap_gib = budget_gib * AIUR_RAM_USABLE_FRAC; - if cap_gib <= AIUR_RAM_BASE_GIB { + let toplevel = system.toplevel(); + if budget_gib < 4.0 { return Err(format!( - "budget {budget_gib} GiB leaves no headroom over the {AIUR_RAM_BASE_GIB} GiB base" + "budget {budget_gib} GiB is below the prover's fixed floor \ + (preprocessed gadget tables + base structures)" )); } - // The ε-discounted headroom above the prove base, in GiB. The cut - // charges BOTH resource terms against it: slope·fft (trace/FFT RAM) - // plus the measured record bytes the prove's execute replays into. - let cut_used_gib = (cap_gib - AIUR_RAM_BASE_GIB) * (1.0 - eps); - // FFT-equivalent of the headroom, for the worker autoscale estimate. - let cut_fft = cut_used_gib / AIUR_RAM_GIB_PER_BFFT * 1e9; + // The ε-discounted cut: a shard ends when its predicted peak prove + // RSS (analytic, from circuit shapes) reaches the margined budget. + let cut_used_gib = budget_gib * PROVE_RAM_MARGIN * (1.0 - eps); let (blocks, adj) = schedule_blocks(env); if blocks.is_empty() { return Err("empty environment".to_string()); } let env_bytes: u64 = blocks.iter().map(|b| b.size).sum(); - let (workers, seg_budget_gib) = fleet_plan(workers, cut_used_gib); + let workers = if workers == 0 { + std::thread::available_parallelism() + .map_or(4, usize::from) + .saturating_sub(2) + .max(1) + } else { + workers + }; let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") .ok() .and_then(|v| v.parse::().ok()) .filter(|&k| k >= 1) .unwrap_or(SCAN_BATCH_BLOCKS); + // The schedule granularity is fixed by the core count so worker sizing + // cannot change the partition. + let sched_pieces = + (std::thread::available_parallelism().map_or(4, usize::from) * 2) + .min(blocks.len()) + .max(16); + let order = ordered_schedule(&blocks, &adj, sched_pieces); + // Post-schedule RSS: the parent's decode cache and static structures — + // the residency the worker pool's budget sits on top of. + let baseline_gib = process_rss_gib(); + // Width-first sizing, uniform for every env and budget: full-core + // width, and each worker's cap is its even share of the pool. Segments + // cut at the additive soft ceiling below the cap, so the budget only + // sets the MERGE target — scan wall never depends on the prove budget. + // Content denser than the cap is a per-block event: the cgroup kill + // names it, and the big-lane retry (whole-pool cap, serialized) rescues + // blocks that are heavy but provable. + let proc_cap_gib = proc_workers.map(|_| { + let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); + let pool_gib = ram.mul_add(0.85, -baseline_gib - 2.0).max(8.0); + std::env::var("IX_SCAN_WORKER_CAP_GIB") + .ok() + .and_then(|v| v.parse::().ok()) + .unwrap_or_else(|| (pool_gib / f64_from_usize(workers)).clamp(6.0, 64.0)) + }); let n_chunks = (workers * 2).min(blocks.len()); eprintln!( - "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut {:.1} \ - GiB combined (≈{:.1} BFFT fft-only), {seg_budget_gib:.1} GiB record \ - share per worker (planned), {batch_blocks} blocks per claim", + "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut at \ + {cut_used_gib:.1} GiB predicted prove RSS (margin \ + {:.0}%, ε pre-charged), {batch_blocks} blocks per claim", blocks.len(), - cut_used_gib, - cut_fft / 1e9 + (1.0 - PROVE_RAM_MARGIN) * 100.0 ); - let order = ordered_schedule(&blocks, &adj, n_chunks); - let chunks = make_chunks(&order, &blocks, env_bytes, n_chunks); - let chunk_count = chunks.len(); + let bounds = make_chunk_bounds(&order, &blocks, env_bytes, n_chunks); + let chunk_count = bounds.len(); let failed: Mutex> = Mutex::new(Vec::new()); let abort = std::sync::atomic::AtomicBool::new(false); let ctx = ScanCtx { @@ -571,101 +1237,84 @@ pub fn scan_shards( failed: &failed, abort: &abort, batch_blocks, - exec_only: false, + system: Some(system), + soft_record_gib: f64::INFINITY, + }; + let segments = match proc_workers { + Some((bin, ixe)) => { + let cap_gib = proc_cap_gib.unwrap_or(16.0); + let soft_gib = (cap_gib - WORKER_OVERHEAD_GIB).max(cap_gib / 2.0); + let cgroups = CgroupBase::create(); + if cgroups.is_none() { + eprintln!( + "[scan] cgroup delegation unavailable — workers run UNCAPPED" + ); + } + eprintln!( + "[scan] process pool: {workers} workers, {cap_gib:.1} GiB cap \ + each{}, soft record cut {soft_gib:.1} GiB", + if cgroups.is_some() { " (cgroup memory.max)" } else { "" }, + ); + let pool = ProcPool { + bin: bin.to_string(), + ixe: ixe.to_string(), + cut_used_gib, + batch_blocks, + soft_record_gib: soft_gib, + pieces: sched_pieces, + exec_only: false, + cap_bytes: gib_to_bytes_u64(cap_gib), + pool_cap_bytes: gib_to_bytes_u64( + crate::kernel::system_ram_gib() + .unwrap_or(64.0) + .mul_add(0.85, -baseline_gib - 2.0) + .max(8.0), + ), + big_lane: Mutex::new(()), + cgroups, + order: &order, + blocks: &blocks, + fail_fast, + }; + run_pool_procs(&pool, bounds, workers, &failed)? + }, + None => { + let chunks = + bounds.iter().map(|&(lo, hi)| order[lo..hi].to_vec()).collect(); + run_pool(&ctx, chunks, workers)? + }, }; - let segments = run_pool(&ctx, chunks, workers)?; - // Merge + re-measure to a fixpoint. Merging by FFT sum is always safe - // (the union's real cost is ≤ the sum: shared deps derive once) but the - // sum badly overstates a shard assembled from many cold mini-segments — - // each paid its own frontier unfolding. So every merged shard is - // re-measured with ONE cold thin-frontier CheckEnv (exactly the claim - // proving pays), and merging reruns with true costs until nothing - // merges. This is what lets the chunk count scale with workers without - // fragmenting the pack or corrupting the cost sidecar. + // Assemble shards by summing adjacent segments up to the cut, to a + // fixpoint. Sums are conservative for every cost in play: shared + // dependencies derive once in the union, and padded heights are + // subadditive — so a summed shard can only OVER-state its prove RSS, + // never breach the budget. The conservatism (measured ~5-15% extra + // shards vs a re-measured pack) is the price of planning wall time + // never depending on the prove budget: segments are scanned at + // RAM-optimal size and packing is pure arithmetic. let pre_merge = segments.len(); - // Batched claims keep the running readout within a couple percent of - // the cold cost (per-claim overhead divided by the batch size), so - // only MERGED shards need a re-measure — their summed costs are the - // one remaining conservative estimate. - let mut list: Vec<(Segment, bool)> = - segments.into_iter().map(|s| (s, false)).collect(); - for round in 0usize.. { - let used = - |sg: &Segment| AIUR_RAM_GIB_PER_BFFT * sg.fft / 1e9 + sg.bytes_gib; - let mut merged: Vec<(Segment, bool)> = Vec::new(); - for (seg, dirty) in list { + let mut list = segments; + loop { + let mut merged: Vec = Vec::new(); + let mut any = false; + for seg in list { match merged.last_mut() { - Some((prev, prev_dirty)) if used(prev) + used(&seg) < cut_used_gib => { + Some(prev) if prev.ram_gib + seg.ram_gib < cut_used_gib => { prev.blocks.extend(seg.blocks); prev.fft += seg.fft; - prev.bytes_gib += seg.bytes_gib; - *prev_dirty = true; + prev.ram_gib += seg.ram_gib; + any = true; }, - _ => merged.push((seg, dirty)), + _ => merged.push(seg), } } list = merged; - let dirty_idx: Vec = list - .iter() - .enumerate() - .filter_map(|(i, (_, d))| d.then_some(i)) - .collect(); - if dirty_idx.is_empty() { - break; - } - if round >= 3 { - // Leftover sums are conservative (over-budget never happens); stop - // refining rather than loop on a pathological pack. - eprintln!( - "[scan] {} shard(s) keep conservative summed costs after {round} \ - refine rounds", - dirty_idx.len() - ); + if !any { break; } - eprintln!( - "[scan] refine round {round}: re-measuring {} merged shard(s)", - dirty_idx.len() - ); - let re_cursor = AtomicUsize::new(0); - let re_results: Mutex>>> = - Mutex::new((0..dirty_idx.len()).map(|_| None).collect()); - std::thread::scope(|s| { - for _ in 0..workers.min(dirty_idx.len()) { - s.spawn(|| { - loop { - let j = re_cursor.fetch_add(1, Ordering::Relaxed); - if j >= dirty_idx.len() { - break; - } - let out = measure_shard(&ctx, &list[dirty_idx[j]].0.blocks); - re_results.lock().unwrap()[j] = Some(out); - } - }); - } - }); - for (j, slot) in re_results.into_inner().unwrap().into_iter().enumerate() { - let (seg, dirty) = &mut list[dirty_idx[j]]; - match slot { - Some(Ok((fft, bytes_gib))) => { - seg.fft = fft; - seg.bytes_gib = bytes_gib; - }, - Some(Err(e)) if !fail_fast => { - // The conservative fft SUM stands for this shard. - eprintln!( - "[scan] re-measure of shard {j} failed ({e}); keeping \ - the summed cost" - ); - }, - Some(Err(e)) => return Err(format!("re-measure shard {j}: {e}")), - None => return Err(format!("re-measure shard {j}: never ran")), - } - *dirty = false; - } } - let segments: Vec = list.into_iter().map(|(s, _)| s).collect(); + let segments = list; // Manifest: owned blocks per segment; frontier fields are the claim // layer's business (reconstructed from env + owned at check/prove time). @@ -711,7 +1360,7 @@ pub fn scan_shards( // Predicted prove RSS = the fft resource line PLUS the measured // record bytes the prove's execute replays into — the second term is // what the fitted line missed on arithmetic-heavy shards. - let ram = aiur_ram_gib_for_fft(seg.fft) + seg.bytes_gib; + let ram = seg.ram_gib; csv.push_str(&format!( "{},{},0,0,0,0,0,0,{:.2},{:.2}\n", id, @@ -720,8 +1369,7 @@ pub fn scan_shards( aiur_prove_secs_for_fft(seg.fft), )); max_ram = max_ram.max(ram); - let used = AIUR_RAM_GIB_PER_BFFT * seg.fft / 1e9 + seg.bytes_gib; - if used >= cut_used_gib / (1.0 - eps) { + if seg.ram_gib >= cut_used_gib / (1.0 - eps) { over += 1; } } @@ -757,8 +1405,8 @@ pub fn scan_shards( Ok(format!( "scan: {} blocks in {} chunks → {num} shards ({pre_merge} pre-merge) @ \ {budget_gib:.0} GiB (cut at {:.1} GiB combined, ε {:.0}%)\nmax \ - predicted prove RSS {max_ram:.1} GiB (fft line + measured record \ - bytes){note}", + predicted prove RSS {max_ram:.1} GiB (analytic, from circuit \ + shapes){note}", blocks.len(), chunk_count, cut_used_gib, @@ -766,32 +1414,6 @@ pub fn scan_shards( )) } -/// Measure one shard's true cold cost: a single thin-frontier `CheckEnv` -/// over its blocks against a fresh record and lazily-faulted witness — -/// the exact execution a prove of this shard performs. -fn measure_shard( - ctx: &ScanCtx<'_>, - block_ids: &[u32], -) -> Result<(f64, f64), String> { - let owned: Vec
= - block_ids.iter().map(|&b| ctx.blocks[b as usize].addr.clone()).collect(); - let mut record = QueryRecord::new(ctx.toplevel); - let mut io = IOBuffer::with_backing(EnvFaultSource::new(ctx.env.clone())); - let (_claim, input) = seed_shard_check_env_claim(ctx.env, &owned, &mut io)?; - execute_ixvm_with_record( - ctx.toplevel, - ctx.fun_idx, - &input, - &mut io, - &mut record, - ) - .map_err(|e| format!("re-measure CheckEnv failed: {e}"))?; - Ok(( - record_fft_cost(ctx.toplevel, &record), - f64_from_usize(record_retained_bytes(&record)) / GIB, - )) -} - /// Number of segments one work-range yields before its remainder goes /// back on the queue for any idle worker. const RANGE_SEGMENTS: usize = 2; @@ -837,12 +1459,12 @@ fn scan_range( let mut record = QueryRecord::new(ctx.toplevel); let mut io = IOBuffer::with_backing(EnvFaultSource::new(ctx.env.clone())); let mut prev_fft = 0.0f64; - let mut prev_bytes = 0.0f64; + let mut prev_ram = 0.0f64; let mut hi = lo; let mut skip_failed = false; - let (seg_end, seg_fft, seg_bytes) = loop { + let (seg_end, seg_fft, seg_ram) = loop { if hi >= chunk.len() { - break (hi, prev_fft, prev_bytes); + break (hi, prev_fft, prev_ram); } if ctx.abort.load(Ordering::Acquire) { return Err("aborted after a failure elsewhere".to_string()); @@ -856,20 +1478,20 @@ fn scan_range( .iter() .map(|&b| ctx.blocks[b as usize].addr.clone()) .collect(); - let out: Result<(), String> = - seed_shard_check_env_claim(ctx.env, &addrs, &mut io).and_then( - |(_claim, input)| { - execute_ixvm_with_record( - ctx.toplevel, - ctx.fun_idx, - &input, - &mut io, - &mut record, - ) - .map(|_| ()) - .map_err(|e| e.to_string()) - }, - ); + let out: Result<(), String> = seed_shard_check_env_claim( + ctx.env, &addrs, &mut io, + ) + .and_then(|(_claim, input)| { + execute_ixvm_with_record( + ctx.toplevel, + ctx.fun_idx, + &input, + &mut io, + &mut record, + ) + .map(|_| ()) + .map_err(|e| e.to_string()) + }); if let Err(e) = out { if k > 1 { // Per-block attribution needed: end the segment at the last @@ -880,7 +1502,7 @@ fn scan_range( {hi}: {e}" ); narrow_until = hi + k; - break (hi, prev_fft, prev_bytes); + break (hi, prev_fft, prev_ram); } let addr = &addrs[0]; if ctx.fail_fast { @@ -899,19 +1521,19 @@ fn scan_range( ); ctx.failed.lock().unwrap().push((addr.clone(), e)); skip_failed = true; - break (hi, prev_fft, prev_bytes); + break (hi, prev_fft, prev_ram); } let fft = record_fft_cost(ctx.toplevel, &record); - let bytes_gib = f64_from_usize(record_retained_bytes(&record)) / GIB; - // Execute-only segments exist to bound the live record, so only - // bytes count against the (per-worker share) cut; the scan's cut - // charges both prove resources against the budget headroom. - let used = if ctx.exec_only { - bytes_gib - } else { - AIUR_RAM_GIB_PER_BFFT * fft / 1e9 + bytes_gib + let rec_gib = f64_from_usize(record_retained_bytes(&record)) / GIB; + // The cut measure: for the scan, the analytic peak-prove-RSS + // prediction from the record's circuit shapes; for execute-only + // segments (which exist only to bound the live record), the + // record's retained bytes against the per-worker share. + let ram_gib = match ctx.system { + Some(sys) => f64_from_usize(sys.peak_prove_bytes(&record).peak) / GIB, + None => rec_gib, }; - if used >= ctx.cut_used_gib { + if ram_gib >= ctx.cut_used_gib || rec_gib >= ctx.soft_record_gib { if hi == lo { if k > 1 { // The segment's first batch crosses the whole cut: find the @@ -921,17 +1543,17 @@ fn scan_range( {hi}: first claim crossed the cut" ); narrow_until = hi + k; - break (hi, prev_fft, prev_bytes); + break (hi, prev_fft, prev_ram); } // A single block alone reaches the cut: atomically infeasible // at this budget — emitted alone with its measured cost. - break (hi + 1, fft, bytes_gib); + break (hi + 1, fft, ram_gib); } - break (hi, prev_fft, prev_bytes); + break (hi, prev_fft, prev_ram); } hi += k; prev_fft = fft; - prev_bytes = bytes_gib; + prev_ram = ram_gib; }; if query_stats_enabled() { dump_query_stats(&record, &format!("scan {chunk_id} seg")); @@ -948,12 +1570,13 @@ fn scan_range( record.function_queries.iter().map(|m| m.len()).sum::() + record.memory_queries.iter().map(|(_, m)| m.len()).sum::(); eprintln!( - "[scan {chunk_id}/{n_chunks}] segment: {} blocks, {:.2} BFFT + \ - {:.1}G rec, {}/{} blocks done, {:.0}s, rss {:.0}G, arena {}M, \ + "[scan {chunk_id}/{n_chunks}] segment: {} blocks, {:.2} BFFT, \ + {:.1}G {}, {}/{} blocks done, {:.0}s, rss {:.0}G, arena {}M, \ iomap {}k, rec {}M", seg_end - lo, seg_fft / 1e9, - seg_bytes, + seg_ram, + if ctx.system.is_some() { "pred-RSS" } else { "rec" }, seg_end, chunk.len(), t0.elapsed().as_secs_f64(), @@ -965,7 +1588,7 @@ fn scan_range( segments.push(Segment { blocks: chunk[lo..seg_end].to_vec(), fft: seg_fft, - bytes_gib: seg_bytes, + ram_gib: seg_ram, }); } lo = seg_end + usize::from(skip_failed); @@ -999,7 +1622,7 @@ use crate::lean::LeanAiurToplevel; /// calibrated resource lines. #[unsafe(no_mangle)] extern "C" fn rs_aiur_scan_shards_with_env( - toplevel: LeanAiurToplevel>, + system: LeanExternal>, fun_idx: LeanNat>, env_handle: LeanExternal< ixvm_codegen::env_handle::EnvHandle, @@ -1010,8 +1633,9 @@ extern "C" fn rs_aiur_scan_shards_with_env( workers: LeanString>, fail_fast: LeanString>, out_path: LeanString>, + worker_bin: LeanString>, + ixe_path: LeanString>, ) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); let fun_idx = crate::aiur::lean_unbox_nat_as_usize(fun_idx.inner()); let budget = budget_gib.to_string().parse::().unwrap_or(0.0); if budget <= 0.0 { @@ -1020,8 +1644,11 @@ extern "C" fn rs_aiur_scan_shards_with_env( let eps = eps_pct.to_string().parse::().unwrap_or(5.0) / 100.0; let workers = workers.to_string().parse::().unwrap_or(0); let fail_fast = fail_fast.to_string() != "0"; + let (bin, ixe) = (worker_bin.to_string(), ixe_path.to_string()); + let proc_workers = (!bin.is_empty() && !ixe.is_empty()) + .then_some((bin.as_str(), ixe.as_str())); match scan_shards( - &toplevel, + system.get(), fun_idx, &env_handle.get().env, budget, @@ -1029,6 +1656,7 @@ extern "C" fn rs_aiur_scan_shards_with_env( workers, fail_fast, &out_path.to_string(), + proc_workers, ) { Ok(report) => { eprintln!("[rs_scan]\n{report}"); @@ -1053,13 +1681,24 @@ extern "C" fn rs_aiur_execute_env_with_env( >, workers: LeanString>, fail_fast: LeanString>, + worker_bin: LeanString>, + ixe_path: LeanString>, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = crate::aiur::lean_unbox_nat_as_usize(fun_idx.inner()); let workers = workers.to_string().parse::().unwrap_or(0); let fail_fast = fail_fast.to_string() != "0"; - match execute_env(&toplevel, fun_idx, &env_handle.get().env, workers, fail_fast) - { + let (bin, ixe) = (worker_bin.to_string(), ixe_path.to_string()); + let proc_workers = (!bin.is_empty() && !ixe.is_empty()) + .then_some((bin.as_str(), ixe.as_str())); + match execute_env( + &toplevel, + fun_idx, + &env_handle.get().env, + workers, + fail_fast, + proc_workers, + ) { Ok(report) => { eprintln!("[rs_exec]\n{report}"); LeanExcept::ok(LeanOwned::box_usize(0)) @@ -1067,3 +1706,43 @@ extern "C" fn rs_aiur_execute_env_with_env( Err(e) => LeanExcept::error_string(&format!("rs_aiur_execute_env: {e}")), } } + +/// `Aiur.AiurSystem.scanWorker`: the child side of the process pool — +/// runs [`scan_worker`]'s stdin/stdout loop until EOF. Numeric params are +/// decimal strings: cut (GiB), batch blocks, soft record cut (GiB), +/// schedule pieces (must match the parent's chunk count), exec-only +/// ("1" = record-bytes cut, no model). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_scan_worker( + system: LeanExternal>, + fun_idx: LeanNat>, + env_handle: LeanExternal< + ixvm_codegen::env_handle::EnvHandle, + LeanBorrowed<'_>, + >, + cut_gib: LeanString>, + batch: LeanString>, + soft_cap_gib: LeanString>, + pieces: LeanString>, + exec_only: LeanString>, +) -> LeanExcept { + let fun_idx = crate::aiur::lean_unbox_nat_as_usize(fun_idx.inner()); + let cut = cut_gib.to_string().parse::().unwrap_or(f64::INFINITY); + let batch = batch.to_string().parse::().unwrap_or(SCAN_BATCH_BLOCKS); + let soft = soft_cap_gib.to_string().parse::().unwrap_or(f64::INFINITY); + let pieces = pieces.to_string().parse::().unwrap_or(16); + let exec_only = exec_only.to_string() == "1"; + match scan_worker( + system.get(), + fun_idx, + &env_handle.get().env, + cut, + batch, + soft, + pieces, + exec_only, + ) { + Ok(()) => LeanExcept::ok(LeanOwned::box_usize(0)), + Err(e) => LeanExcept::error_string(&format!("rs_aiur_scan_worker: {e}")), + } +} diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 610695f41..63a05c8d2 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -3114,9 +3114,8 @@ pub(crate) fn system_ram_gib() -> Option { /// `.ixes` manifest. `max_cycles` is a guest-STEP cap; if `ram_gb` > 0 it is /// converted via the measured prover RAM model and overrides `max_cycles`. Pass /// "0" for both to default the budget to detected system RAM. `backend` -/// selects the cost model: "zisk" (default) packs to the guest-STEP cap, -/// "aiur" packs to the Aiur RAM model (RAM budgets only — a cycle cap is a -/// Zisk-specific unit). +/// must be "zisk" (guest-STEP cap); "aiur" is rejected — Aiur shards via +/// the measured scan on the `.ixe`, not a model packer. #[allow(clippy::cast_precision_loss)] #[unsafe(no_mangle)] pub extern "C" fn rs_shard_esp_cap( @@ -3152,26 +3151,9 @@ pub extern "C" fn rs_shard_esp_cap( } } if aiur { - if ram <= 0.0 { - return LeanIOResult::error_string( - "shard --backend aiur sizes by RAM; pass --max-ram G (a cycle cap is a Zisk unit)", - ); - } - let out = out_path.to_string(); - let out_opt = if out.is_empty() { None } else { Some(out.as_str()) }; - return match ix_kernel::shard::shard_esp_aiur( - &esp_path.to_string(), - ram, - balance, - parallelism, - out_opt, - ) { - Ok(report) => { - eprintln!("[rs_shard]\n{report}"); - LeanIOResult::ok(LeanOwned::box_usize(0)) - }, - Err(e) => LeanIOResult::error_string(&format!("rs_shard_esp_cap: {e}")), - }; + return LeanIOResult::error_string( + "the Aiur model packer was removed; run the measured scan instead: ix shard --max-ram G", + ); } let cap = if ram > 0.0 { ix_kernel::shard::cycle_cap_for_ram(ram) } else { mc }; @@ -3197,47 +3179,6 @@ pub extern "C" fn rs_shard_esp_cap( } } -/// FFI: surgically split ONE shard of an existing Aiur `.ixes` manifest at a -/// smaller per-shard RAM budget. Every other shard's block list is copied -/// verbatim (their claims and cached proofs stay valid); shard `k` is -/// replaced by its children (first child keeps id `k`, the rest append at -/// the end). -#[unsafe(no_mangle)] -pub extern "C" fn rs_shard_rebudget( - esp_path: LeanString>, - manifest_path: LeanString>, - shard_k: LeanString>, - ram_gb: LeanString>, - balance_pct: LeanString>, - out_path: LeanString>, -) -> LeanIOResult { - let k = match shard_k.to_string().parse::() { - Ok(k) => k, - Err(_) => return LeanIOResult::error_string("rebudget: bad shard index"), - }; - let ram = ram_gb.to_string().parse::().unwrap_or(0.0); - if ram <= 0.0 { - return LeanIOResult::error_string( - "rebudget: pass a positive per-child RAM budget (GiB)", - ); - } - let balance = balance_pct.to_string().parse::().unwrap_or(5.0) / 100.0; - match ix_kernel::shard::rebudget_manifest_shard( - &esp_path.to_string(), - &manifest_path.to_string(), - k, - ram, - balance, - &out_path.to_string(), - ) { - Ok(report) => { - eprintln!("[rs_shard_rebudget]\n{report}"); - LeanIOResult::ok(LeanOwned::box_usize(0)) - }, - Err(e) => LeanIOResult::error_string(&format!("rs_shard_rebudget: {e}")), - } -} - #[cfg(test)] mod tests { use super::{compact_in_flight_label, resolve_kernel_check_workers_from}; diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index 0cea47ca0..b87112954 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -75,7 +75,7 @@ clippy::needless_range_loop )] -use rustc_hash::{FxHashMap, FxHashSet}; +use rustc_hash::FxHashSet; use std::cmp::Reverse; use std::collections::BinaryHeap; use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering}; @@ -1295,7 +1295,8 @@ impl ShardCost { pub fn value(self) -> u64 { match self { Self::Unknown => 0, - Self::ProfileHeartbeats(v) | Self::ZiskCostUnits(v) + Self::ProfileHeartbeats(v) + | Self::ZiskCostUnits(v) | Self::AiurFft(v) => v, } } @@ -1438,8 +1439,7 @@ impl ShardManifest { /// A human-readable what-if summary line. pub fn summary(&self) -> String { - let costs: Vec = - self.shards.iter().map(|s| s.cost.value()).collect(); + let costs: Vec = self.shards.iter().map(|s| s.cost.value()).collect(); let nonempty: Vec = self .shards .iter() @@ -1739,412 +1739,6 @@ pub fn shard_esp_cap( )) } -/// Like [`shard_esp_cap`] but sized to a per-shard **Aiur host-RAM** budget -/// (GiB) via the calibrated Aiur cost model (see [`partition_for_aiur_ram`]). -/// The manifest format is backend-neutral; only the packing objective and the -/// report change. Alongside the manifest a `.costs.csv` sidecar records -/// the packer's per-shard accounting and predictions, for -/// measured-vs-predicted comparison, refits, and heaviest-first prove -/// scheduling. -pub fn shard_esp_aiur( - esp_path: &str, - ram_budget_gib: f64, - balance: f64, - parallelism: usize, - out_path: Option<&str>, -) -> Result { - let bytes = - std::fs::read(esp_path).map_err(|e| format!("read {esp_path}: {e}"))?; - let profile = BlockProfile::from_bytes(&bytes) - .map_err(|e| format!("parse {esp_path}: {e}"))?; - if !profile.has_touch_graph() && !profile.has_ref_graph() { - return Err(format!( - "{esp_path} has neither a touch graph nor a reference graph — Aiur \ - packing needs one for its faulted-set byte accounting; regenerate \ - with the current `ix profile`" - )); - } - let plan = partition_for_aiur_ram(&profile, ram_budget_gib, balance); - let mut manifest = - ShardManifest::build(&profile, &plan.shard_of, plan.num_shards) - .with_tree(plan.tree); - for (shard, c) in manifest.shards.iter_mut().zip(&plan.shard_costs) { - shard.assumption_root = - ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); - shard.cost = ShardCost::AiurFft(cost_fft(aiur_shard_fft( - c.union_bytes, - c.subst, - c.def_eq, - ))); - } - if let Some(op) = out_path { - std::fs::write(op, manifest.to_bytes()) - .map_err(|e| format!("write {op}: {e}"))?; - } - let prove_secs: Vec = plan - .shard_costs - .iter() - .map(|c| aiur_prove_secs(c.union_bytes, c.subst, c.def_eq)) - .collect(); - if let Some(op) = out_path { - let mut csv = String::from( - "shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,\ - pred_ram_gib,pred_prove_s\n", - ); - for (i, c) in plan.shard_costs.iter().enumerate() { - csv.push_str(&format!( - "{},{},{},{},{},{},{},{},{:.2},{:.2}\n", - i, - c.union_bytes, - c.hb, - c.subst, - c.subst_unique, - c.whnf, - c.def_eq, - c.nat_arith, - aiur_ram_gib(c.union_bytes, c.subst, c.def_eq), - prove_secs[i], - )); - } - let cp = format!("{op}.costs.csv"); - std::fs::write(&cp, csv).map_err(|e| format!("write {cp}: {e}"))?; - } - let seq_secs: f64 = prove_secs.iter().sum(); - let max_secs = prove_secs.iter().fold(0.0f64, |a, &s| a.max(s)); - let p = parallelism.max(1); - #[allow(clippy::cast_precision_loss)] - let wall_secs = (seq_secs / p as f64).max(max_secs); - let note = if plan.infeasible_atomic_floor { - "\n [INFEASIBLE: a single atomic block exceeds the RAM cap — split it upstream, raise the budget, or use a bigger box]" - } else { - "" - }; - Ok(format!( - "blocks={} delta_edges={} aiur ram_budget={:.0} GiB (cap {:.1} at {:.0}% usable) → {} shards (packed to cap)\n{}\nprove est ~{} wall at parallelism={} (sequential ~{})\nmax_shard_ram={:.1} GiB largest_block_ram={:.1} GiB{}", - profile.num_blocks(), - profile.num_edges(), - ram_budget_gib, - plan.ram_cap_gib, - AIUR_RAM_USABLE_FRAC * 100.0, - plan.num_shards, - manifest.summary(), - fmt_duration(wall_secs), - p, - fmt_duration(seq_secs), - plan.max_shard_ram_gib, - plan.largest_block_ram_gib, - note, - )) -} - -/// Greedy next-fit packing of one block subset to a RAM cap, with the same -/// faulted-set union accounting as [`partition_for_aiur_ram`]'s packing walk -/// (measured touch sets when the profile has them, reference-closure BFS -/// otherwise). Returns the children as block-id lists, in pack order. -fn pack_block_subset_to_cap( - profile: &BlockProfile, - blocks_in_order: &[u32], - cap_gib: f64, -) -> Vec> { - let size = |b: u32| u64::from(profile.block(b).serialized_size); - let measured = profile.has_touch_graph(); - let mut children: Vec> = Vec::new(); - let mut cur: Vec = Vec::new(); - let mut cur_cost = AiurShardCost::default(); - let mut charged: FxHashSet = FxHashSet::default(); - let mut walked: FxHashSet = FxHashSet::default(); - let predicted = - |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.subst, c.def_eq); - - let union_delta = |b: u32, - charged: &mut FxHashSet, - walked: &mut FxHashSet| - -> u64 { - let mut bytes = 0u64; - let charge = |x: u32, charged: &mut FxHashSet, bytes: &mut u64| { - if charged.insert(x) { - *bytes = bytes.saturating_add(size(x)); - } - }; - if measured { - charge(b, charged, &mut bytes); - for &t in profile.touched_blocks(b) { - charge(t, charged, &mut bytes); - } - } else if walked.insert(b) { - let mut stack = vec![b]; - while let Some(x) = stack.pop() { - charge(x, charged, &mut bytes); - for &r in profile.refs(x) { - if walked.insert(r) { - stack.push(r); - } - } - } - } - bytes - }; - - for &b in blocks_in_order { - let e = profile.block(b); - let delta = union_delta(b, &mut charged, &mut walked); - // The tentative cost must carry every model feature, or the cap test - // under-predicts the candidate shard. - let tentative = AiurShardCost { - union_bytes: cur_cost.union_bytes.saturating_add(delta), - hb: cur_cost.hb.saturating_add(e.heartbeats), - subst: cur_cost.subst.saturating_add(e.subst), - def_eq: cur_cost.def_eq.saturating_add(e.def_eq), - ..cur_cost - }; - if !cur.is_empty() && predicted(&tentative) > cap_gib { - children.push(std::mem::take(&mut cur)); - charged.clear(); - walked.clear(); - cur_cost = AiurShardCost::default(); - cur_cost.union_bytes = union_delta(b, &mut charged, &mut walked); - } else { - cur_cost.union_bytes = tentative.union_bytes; - } - cur_cost.hb = cur_cost.hb.saturating_add(e.heartbeats); - cur_cost.subst = cur_cost.subst.saturating_add(e.subst); - cur_cost.def_eq = cur_cost.def_eq.saturating_add(e.def_eq); - cur.push(b); - } - if !cur.is_empty() { - children.push(cur); - } - children -} - -/// Surgically re-partition ONE shard of an existing Aiur manifest at a -/// smaller per-shard RAM budget — the recourse when the cost model's blind -/// spot packs an outlier shard past what the box can prove. Every other -/// shard's block list is reproduced VERBATIM (asserted), so its claim digest -/// — and any cached proof keyed on it in `~/.ix/cache/shard-proofs/` — stays -/// valid; only shard `k` is replaced by its children. The first child keeps -/// id `k`, the rest are appended, and the aggregation tree's leaf `k` -/// becomes a left-leaning chain over the children. -pub fn rebudget_manifest_shard( - esp_path: &str, - manifest_path: &str, - shard_k: usize, - child_budget_gib: f64, - epsilon: f64, - out_path: &str, -) -> Result { - let bytes = - std::fs::read(esp_path).map_err(|e| format!("read {esp_path}: {e}"))?; - let profile = BlockProfile::from_bytes(&bytes) - .map_err(|e| format!("parse {esp_path}: {e}"))?; - if !profile.has_touch_graph() && !profile.has_ref_graph() { - return Err(format!( - "{esp_path} has neither a touch graph nor a reference graph — \ - rebudget needs the faulted-set accounting; regenerate with the \ - current `ix profile`" - )); - } - let mbytes = std::fs::read(manifest_path) - .map_err(|e| format!("read {manifest_path}: {e}"))?; - let manifest = ShardManifest::from_bytes(&mbytes) - .map_err(|e| format!("parse {manifest_path}: {e}"))?; - let old_n = manifest.shards.len(); - let parent = manifest - .shards - .get(shard_k) - .ok_or_else(|| format!("shard {shard_k} out of range (0..{old_n})"))?; - - let id_of: FxHashMap<&Address, u32> = profile - .blocks() - .iter() - .enumerate() - .map(|(i, b)| (&b.addr, i as u32)) - .collect(); - let to_id = |a: &Address| -> Result { - id_of - .get(a) - .copied() - .ok_or_else(|| format!("manifest block {a:?} not in profile")) - }; - let parent_blocks: FxHashSet = - parent.blocks.iter().map(&to_id).collect::>()?; - - // Pack the parent's blocks at the child budget, in the same cut-coherent - // global order the original partition used. - let cap_gib = child_budget_gib * AIUR_RAM_USABLE_FRAC; - let total_bytes: u64 = profile - .blocks() - .iter() - .fold(0u64, |a, b| a.saturating_add(u64::from(b.serialized_size))); - let total_subst: u64 = - profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.subst)); - let total_def_eq: u64 = - profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.def_eq)); - let base_ram = aiur_ram_gib(0, 0, 0); - let total_ram = - aiur_ram_gib(total_bytes, total_subst, total_def_eq) - base_ram; - let headroom = (cap_gib - base_ram).max(f64::MIN_POSITIVE); - #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] - let pieces = (total_ram / headroom * PACK_PIECES_PER_CAP as f64) as usize; - let order = cut_coherent_order(&profile, pieces, epsilon); - let subset: Vec = - order.iter().copied().filter(|b| parent_blocks.contains(b)).collect(); - let children_ids = pack_block_subset_to_cap(&profile, &subset, cap_gib); - let n_children = children_ids.len(); - if n_children <= 1 { - return Err(format!( - "shard {shard_k} does not split at budget {child_budget_gib} GiB \ - (cap {cap_gib:.1}): got {n_children} child(ren) — lower the budget" - )); - } - - // Modified assignment: child 0 keeps id `shard_k`; the rest append. - let mut shard_of: Vec = vec![0; profile.num_blocks()]; - for (s, info) in manifest.shards.iter().enumerate() { - if s == shard_k { - continue; - } - for a in &info.blocks { - shard_of[to_id(a)? as usize] = s as u32; - } - } - let new_n = old_n + n_children - 1; - for (c, ids) in children_ids.iter().enumerate() { - let sid = if c == 0 { shard_k as u32 } else { (old_n + c - 1) as u32 }; - for &b in ids { - shard_of[b as usize] = sid; - } - } - - // `ShardManifest::build` is deterministic in (profile, shard_of), so the - // untouched shards reproduce byte-identically — asserted below, because - // that identity is exactly what keeps their claim digests (and cached - // proofs) valid. - let mut rebuilt = ShardManifest::build(&profile, &shard_of, new_n); - for shard in &mut rebuilt.shards { - shard.assumption_root = - ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); - } - for s in 0..old_n { - if s == shard_k { - continue; - } - if rebuilt.shards[s].blocks != manifest.shards[s].blocks { - return Err(format!( - "rebudget internal error: shard {s}'s block list changed — refusing \ - to write a manifest that would invalidate its cached proof" - )); - } - } - // Patch the aggregation tree: the parent's leaf becomes a left-leaning - // chain over its children, keeping every other leaf untouched. - fn patch_tree(node: &AggNode, k: u32, extra: &[u32]) -> AggNode { - match node { - AggNode::Leaf(id) if *id == k => { - let mut t = AggNode::Leaf(k); - for &e in extra { - t = AggNode::Internal(Box::new(t), Box::new(AggNode::Leaf(e))); - } - t - }, - AggNode::Leaf(id) => AggNode::Leaf(*id), - AggNode::Internal(l, r) => AggNode::Internal( - Box::new(patch_tree(l, k, extra)), - Box::new(patch_tree(r, k, extra)), - ), - } - } - let extra_ids: Vec = - (0..n_children - 1).map(|i| (old_n + i) as u32).collect(); - rebuilt.tree = - manifest.tree.as_ref().map(|t| patch_tree(t, shard_k as u32, &extra_ids)); - - // Costs sidecar: recompute every row's faulted-set union from the profile - // (identical to the input rows for untouched shards — the union is a - // function of the owned set alone). Untouched shards keep the INPUT - // manifest's cost (a scan's measured fft survives a rebudget of a - // sibling); children get the model prediction. - let measured = profile.has_touch_graph(); - let mut csv = String::from( - "shard,union_bytes,hb,subst,subst_unique,whnf,def_eq,nat_arith,\ - pred_ram_gib,pred_prove_s\n", - ); - let mut report = String::new(); - let mut union_set: FxHashSet = FxHashSet::default(); - for i in 0..rebuilt.shards.len() { - let ids: Vec = rebuilt.shards[i] - .blocks - .iter() - .map(&to_id) - .collect::>()?; - union_set.clear(); - for &b in &ids { - union_set.insert(b); - if measured { - union_set.extend(profile.touched_blocks(b).iter().copied()); - } else { - let mut stack = vec![b]; - while let Some(x) = stack.pop() { - for &r in profile.refs(x) { - if union_set.insert(r) { - stack.push(r); - } - } - } - } - } - let union_bytes: u64 = union_set - .iter() - .map(|&b| u64::from(profile.block(b).serialized_size)) - .sum(); - let sum = |f: &dyn Fn(u32) -> u64| ids.iter().map(|&b| f(b)).sum::(); - let subst = sum(&|b| profile.block(b).subst); - let subst_unique = sum(&|b| profile.block(b).subst_unique); - let whnf = sum(&|b| profile.block(b).whnf); - let def_eq = sum(&|b| profile.block(b).def_eq); - let nat_arith = sum(&|b| profile.block(b).nat_arith); - let ram = aiur_ram_gib(union_bytes, subst, def_eq); - rebuilt.shards[i].cost = if i != shard_k && i < old_n { - manifest.shards[i].cost - } else { - ShardCost::AiurFft(cost_fft(aiur_shard_fft( - union_bytes, - subst, - def_eq, - ))) - }; - csv.push_str(&format!( - "{},{},{},{},{},{},{},{},{:.2},{:.2}\n", - i, - union_bytes, - rebuilt.shards[i].cost.value(), - subst, - subst_unique, - whnf, - def_eq, - nat_arith, - ram, - aiur_prove_secs(union_bytes, subst, def_eq), - )); - if i == shard_k || i >= old_n { - report.push_str(&format!( - " child shard {i}: {} blocks, union {:.1} MB, pred_ram {ram:.2} GiB\n", - rebuilt.shards[i].blocks.len(), - union_bytes as f64 / 1e6, - )); - } - } - std::fs::write(out_path, rebuilt.to_bytes()) - .map_err(|e| format!("write {out_path}: {e}"))?; - let cp = format!("{out_path}.costs.csv"); - std::fs::write(&cp, csv).map_err(|e| format!("write {cp}: {e}"))?; - - Ok(format!( - "rebudget shard {shard_k} @ {child_budget_gib} GiB (cap {cap_gib:.1}): \ - {old_n} → {new_n} shards; all other shards copied verbatim\n{report}" - )) -} - /// Calibrated Zisk guest-COST model — the **single source of truth** for /// predicting a block's in-circuit cost contribution, in **ziskemu cost /// units** (`ziskemu -X` TOTAL: MAIN + OPCODES + MEMORY + PRECOMPILES + @@ -2270,6 +1864,10 @@ fn nlogn(x: u64) -> f64 { x * (x + 2.0).log2() } +/// LEGACY counter-model constants: advisory pricing for `ix profile` +/// sweep/leaderboards only. Superseded for shard sizing by the measured +/// scan + analytic peak-prove-RAM model; do not use these to size shards. +/// /// Calibrated two-stage Aiur cost model. /// /// **Stage 1** predicts a run's total FFT cost (the prover's actual work @@ -2644,300 +2242,6 @@ pub fn partition_for_cycle_cap( } } -/// One shard's Aiur cost aggregates as the packer accounted them: the -/// faulted-set ingress bytes plus the owned blocks' checking counters. -#[derive(Clone, Copy, Debug, Default)] -pub struct AiurShardCost { - /// Serialized bytes of the shard's faulted set (owned ∪ every block the - /// owned checks consulted per the touch graph; full reference closure - /// when no touch graph was recorded) — what the shard's CheckEnv run - /// ingresses and hashes under the lazy kernel. - pub union_bytes: u64, - /// Σ heartbeats over owned blocks only (frontier constants are assumptions, - /// never re-checked). - pub hb: u64, - /// Σ substitution-node visits over owned blocks only. - pub subst: u64, - /// Σ memo-unique substitution work items over owned blocks only — the - /// post-memoization volume a memoizing executor pays; persisted per shard - /// so the models can eventually be refit against it. - pub subst_unique: u64, - /// Σ `whnf` entries over owned blocks only. - pub whnf: u64, - /// Σ definitional-equality checks over owned blocks only. - pub def_eq: u64, - /// Σ big-Nat limb-work units over owned blocks only — the klimbs - /// circuit family's only recorded signal; persisted per shard so the - /// RAM model's content residual can eventually be fit against it. - pub nat_arith: u64, -} - -/// A partition sized to a per-shard Aiur host-RAM budget. The Aiur analog of -/// [`BudgetPlan`], reported in the Aiur model's native unit (GiB) rather than -/// guest steps. -pub struct AiurBudgetPlan { - /// Chosen shard count. - pub num_shards: usize, - /// Shard assignment per block id. - pub shard_of: Vec, - /// The bisection tree for the chosen partition, for tree-aligned aggregation. - pub tree: AggNode, - /// Per-shard predicted-RAM cap actually enforced: - /// `budget × AIUR_RAM_USABLE_FRAC`. - pub ram_cap_gib: f64, - /// Per-shard cost aggregates, indexed by shard id. - pub shard_costs: Vec, - /// Heaviest shard's full predicted RAM — the tightest number to compare - /// against the cap. - pub max_shard_ram_gib: f64, - /// Largest single block's predicted RAM with its full faulted-set ingress — - /// the hard floor no shard count can beat: every shard containing the - /// block faults in at least that set. - pub largest_block_ram_gib: f64, - /// True when one block alone (faulted set included) exceeds the cap. - pub infeasible_atomic_floor: bool, -} - -/// Size a partition to a per-shard Aiur host-RAM budget by bin-packing to the -/// cap — the Aiur counterpart of [`partition_for_cycle_cap`], with the same -/// cut-coherent-order + greedy next-fit structure but **faulted-set byte -/// accounting**. -/// -/// Under the addr-first kernel a shard's witness ships its owned blocks' full -/// dependency closure, but only bytes the checks actually fault in cost -/// ingress trace rows (an unfaulted constant contributes zero queries), so -/// the packer charges the *faulted* set. With a **touch graph** (recorded by -/// a profiling run) that set is a measurement: each owned block contributes -/// itself plus every block its check consulted — type reads included, and -/// transitively complete because consults during reduction are recorded -/// against the owned consumer. Without a touch graph the accounting falls -/// back to the full reference closure, an over-approximation that -/// over-shards but never under-budgets. -/// -/// Checking counters (hb/subst/…) stay owned-blocks-only. Grouping blocks -/// with overlapping faulted sets is the packing objective that matters: a -/// shared dependency's bytes are paid once per shard that faults it. -/// -/// Requires the profile's reference graph when no touch graph is present; -/// the caller rejects profiles with neither. -pub fn partition_for_aiur_ram( - profile: &BlockProfile, - ram_budget_gib: f64, - epsilon: f64, -) -> AiurBudgetPlan { - let ram_cap_gib = ram_budget_gib * AIUR_RAM_USABLE_FRAC; - let nblocks = profile.num_blocks(); - let size = |b: u32| u64::from(profile.block(b).serialized_size); - let measured = profile.has_touch_graph(); - - if nblocks == 0 { - return AiurBudgetPlan { - num_shards: 1, - shard_of: Vec::new(), - tree: AggNode::Leaf(0), - ram_cap_gib, - shard_costs: Vec::new(), - max_shard_ram_gib: aiur_ram_gib(0, 0, 0), - largest_block_ram_gib: 0.0, - infeasible_atomic_floor: false, - }; - } - - // Per-block faulted-set bytes (the block's lone-shard ingress) — the RAM - // floor per block and the infeasibility test. Measured: the touch row is - // already the transitive consult set. Fallback: full reference-closure - // BFS, parallel with per-worker epoch-marked state. - let closure_bytes: Vec = if measured { - (0..nblocks as u32) - .map(|b| { - profile - .touched_blocks(b) - .iter() - .map(|&t| size(t)) - .fold(size(b), u64::saturating_add) - }) - .collect() - } else { - use rayon::prelude::*; - (0..nblocks as u32) - .into_par_iter() - .map_init( - || (vec![0u32; nblocks], 0u32, Vec::::new()), - |(visited, epoch, stack), b| { - *epoch += 1; - let mut bytes = 0u64; - stack.clear(); - stack.push(b); - visited[b as usize] = *epoch; - while let Some(x) = stack.pop() { - bytes = bytes.saturating_add(size(x)); - for &r in profile.refs(x) { - if visited[r as usize] != *epoch { - visited[r as usize] = *epoch; - stack.push(r); - } - } - } - bytes - }, - ) - .collect() - }; - let lone_block_ram = |b: u32| { - aiur_ram_gib( - closure_bytes[b as usize], - profile.block(b).subst, - profile.block(b).def_eq, - ) - }; - let largest_block_ram_gib = - (0..nblocks as u32).map(lone_block_ram).fold(0.0, f64::max); - - // 1. Cut-coherent block order. Piece sizing uses the whole-env totals as a - // granularity proxy (faulted-set bytes are not additive across pieces); - // the order's job is only to keep overlapping blocks adjacent, which - // the min-cut on shared-dependency nets already does. - let total_bytes: u64 = profile - .blocks() - .iter() - .fold(0u64, |a, b| a.saturating_add(u64::from(b.serialized_size))); - let total_subst: u64 = - profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.subst)); - let total_def_eq: u64 = - profile.blocks().iter().fold(0u64, |a, b| a.saturating_add(b.def_eq)); - let base_ram = aiur_ram_gib(0, 0, 0); - let total_ram = - aiur_ram_gib(total_bytes, total_subst, total_def_eq) - base_ram; - let headroom = (ram_cap_gib - base_ram).max(f64::MIN_POSITIVE); - #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] - let pieces = (total_ram / headroom * PACK_PIECES_PER_CAP as f64) as usize; - let order = cut_coherent_order(profile, pieces, epsilon); - - // 2. Greedy next-fit packing to the RAM cap with live faulted-union - // accounting. `charged_mark[x] == shard_epoch` ⇔ x's bytes are already - // in the current shard's union; closing a shard bumps the epoch, which - // invalidates every mark at once (a rejected tentative walk leaves no - // residue — the candidate re-walks fresh in the next shard). - let mut shard_of = vec![0u32; nblocks]; - let mut charged_mark = vec![0u32; nblocks]; - let mut walk_mark = vec![0u32; nblocks]; - let mut shard_epoch = 1u32; - let mut stack: Vec = Vec::new(); - let mut cur_cost = AiurShardCost::default(); - let mut shard_costs: Vec = Vec::new(); - let mut cur = 0u32; - let mut owned_in_cur = 0usize; - let mut infeasible = false; - let predicted = - |c: &AiurShardCost| aiur_ram_gib(c.union_bytes, c.subst, c.def_eq); - - // Byte delta of adding `b`'s faulted set to the current shard's union. - let union_delta = |b: u32, - shard_epoch: u32, - stack: &mut Vec, - charged_mark: &mut [u32], - walk_mark: &mut [u32]| - -> u64 { - let mut bytes = 0u64; - let charge = |x: u32, charged_mark: &mut [u32], bytes: &mut u64| { - if charged_mark[x as usize] != shard_epoch { - charged_mark[x as usize] = shard_epoch; - *bytes = bytes.saturating_add(size(x)); - } - }; - if measured { - charge(b, charged_mark, &mut bytes); - for &t in profile.touched_blocks(b) { - charge(t, charged_mark, &mut bytes); - } - } else { - // Reference-closure BFS, deduped per shard: a subtree expanded once - // this epoch is never re-walked for a later member. - if walk_mark[b as usize] != shard_epoch { - stack.clear(); - stack.push(b); - walk_mark[b as usize] = shard_epoch; - while let Some(x) = stack.pop() { - charge(x, charged_mark, &mut bytes); - for &r in profile.refs(x) { - if walk_mark[r as usize] != shard_epoch { - walk_mark[r as usize] = shard_epoch; - stack.push(r); - } - } - } - } - } - bytes - }; - - for &b in &order { - let e = profile.block(b); - let delta = union_delta( - b, - shard_epoch, - &mut stack, - &mut charged_mark, - &mut walk_mark, - ); - // The tentative cost must carry every model feature, or the cap test - // under-predicts the candidate shard. - let tentative = AiurShardCost { - union_bytes: cur_cost.union_bytes.saturating_add(delta), - hb: cur_cost.hb.saturating_add(e.heartbeats), - subst: cur_cost.subst.saturating_add(e.subst), - def_eq: cur_cost.def_eq.saturating_add(e.def_eq), - ..cur_cost - }; - - if owned_in_cur > 0 && predicted(&tentative) > ram_cap_gib { - // Close the shard, open a fresh union, re-walk b's faulted set. - shard_costs.push(cur_cost); - cur += 1; - shard_epoch += 1; - owned_in_cur = 0; - cur_cost = AiurShardCost::default(); - cur_cost.union_bytes = union_delta( - b, - shard_epoch, - &mut stack, - &mut charged_mark, - &mut walk_mark, - ); - } else { - cur_cost.union_bytes = tentative.union_bytes; - } - cur_cost.hb = cur_cost.hb.saturating_add(e.heartbeats); - cur_cost.subst = cur_cost.subst.saturating_add(e.subst); - cur_cost.subst_unique = - cur_cost.subst_unique.saturating_add(e.subst_unique); - cur_cost.whnf = cur_cost.whnf.saturating_add(e.whnf); - cur_cost.def_eq = cur_cost.def_eq.saturating_add(e.def_eq); - cur_cost.nat_arith = cur_cost.nat_arith.saturating_add(e.nat_arith); - owned_in_cur += 1; - shard_of[b as usize] = cur; - if owned_in_cur == 1 && predicted(&cur_cost) > ram_cap_gib { - infeasible = true; - } - } - shard_costs.push(cur_cost); - let max_shard_ram_gib = shard_costs.iter().map(predicted).fold(0.0, f64::max); - - let num_shards = (cur + 1) as usize; - let tree = balanced_agg_tree(0, num_shards as u32); - - AiurBudgetPlan { - num_shards, - shard_of, - tree, - ram_cap_gib, - shard_costs, - max_shard_ram_gib, - largest_block_ram_gib, - infeasible_atomic_floor: infeasible, - } -} - /// A cut-coherent block order for greedy cap-packing: a fine min-cut /// pre-partition's bisection tree, read in DFS order, lays tightly-coupled /// blocks contiguously so a next-fit packer keeps dependency overlap within a @@ -3245,124 +2549,6 @@ mod tests { p } - #[test] - fn aiur_ram_cap_respected() { - // 40-block chain (each references the next), uniform weights: the packer - // must split into multiple shards each under the (usable-fraction) cap, - // where a shard's bytes are its closure UNION — for a chain, everything - // downstream of its first member. - let mut b = ProfileBuilder::new(); - for i in 1..=40u8 { - b.block(addr(i), 10_000, 20_000, 1, ops(5_000_000)); - } - for i in 1..40u8 { - b.delta_edge(addr(i), addr(i + 1)); - } - let adj: Vec> = - (0..40u32).map(|i| if i < 39 { vec![i + 1] } else { vec![] }).collect(); - let p = with_refs(b.finish(), &adj); - let budget = 64.0; - let plan = partition_for_aiur_ram(&p, budget, 0.05); - assert!(plan.num_shards > 1, "must shard: whole env exceeds the budget"); - assert!( - plan.max_shard_ram_gib <= plan.ram_cap_gib, - "heaviest shard {} exceeds cap {}", - plan.max_shard_ram_gib, - plan.ram_cap_gib, - ); - // Every block is assigned, ids contiguous. - assert_eq!(plan.shard_of.len(), 40); - let max_id = plan.shard_of.iter().copied().max().unwrap() as usize; - assert_eq!(max_id + 1, plan.num_shards); - } - - #[test] - fn aiur_union_counts_shared_dep_once() { - // Blocks 0 and 1 both reference deep dep 2 (which references 3). Packed - // into one shard, the union must charge {0,1,2,3} once — NOT - // closure(0)+closure(1). - let mut b = ProfileBuilder::new(); - for i in 1..=4u8 { - b.block(addr(i), 10, 1000, 1, ops(0)); - } - let p = with_refs(b.finish(), &[vec![2], vec![2], vec![3], vec![]]); - let plan = partition_for_aiur_ram(&p, 1000.0, 0.05); - assert_eq!(plan.num_shards, 1); - assert_eq!(plan.shard_costs[0].union_bytes, 4000); - assert_eq!(plan.shard_costs[0].hb, 40); - } - - #[test] - fn aiur_measured_charges_touched_not_closure() { - // refs 0→1, 1→{2,3}; the recording run's check of block 0 consulted only - // 1 (touch edge). Measured accounting charges block 0's faulted set - // {0,1} = 2000 — the reference closure {0,1,2,3} = 4000 is what a - // touch-free profile falls back to. - let build = |touch: bool| { - let mut b = ProfileBuilder::new(); - for i in 1..=4u8 { - b.block(addr(i), 10, 1000, 1, ops(0)); - } - if touch { - b.touch_edge(addr(1), addr(2)); - } - with_refs(b.finish(), &[vec![1], vec![2, 3], vec![], vec![]]) - }; - let fallback = partition_for_aiur_ram(&build(false), 1000.0, 0.05); - assert!( - (fallback.largest_block_ram_gib - aiur_ram_gib(4000, 0, 0)).abs() < 1e-9 - ); - let measured = partition_for_aiur_ram(&build(true), 1000.0, 0.05); - assert!( - (measured.largest_block_ram_gib - aiur_ram_gib(2000, 0, 0)).abs() < 1e-9 - ); - } - - #[test] - fn aiur_ingress_expands_refs_when_member_becomes_owned() { - // Block 0 refs 1; block 1 refs 2. Packing 0 first pulls 1 (and, via the - // closure walk, 2) into the union; packing 1 as OWNED afterwards must - // not double-charge any of them. - let mut b = ProfileBuilder::new(); - for i in 1..=3u8 { - b.block(addr(i), 10, 1000, 1, ops(0)); - } - let p = with_refs(b.finish(), &[vec![1], vec![2], vec![]]); - let plan = partition_for_aiur_ram(&p, 1000.0, 0.05); - assert_eq!(plan.num_shards, 1); - assert_eq!(plan.shard_costs[0].union_bytes, 3000); - } - - #[test] - fn aiur_floor_is_closure_bytes() { - // A cheap block referencing a huge dependency: its lone-shard RAM floor - // must include the dependency's bytes even though its own are tiny. - let mut b = ProfileBuilder::new(); - b.block(addr(1), 10, 100, 1, ops(0)); - b.block(addr(2), 10, 3_000_000, 1, ops(0)); - let p = with_refs(b.finish(), &[vec![1], vec![]]); - let plan = partition_for_aiur_ram(&p, 1000.0, 0.05); - let floor = aiur_ram_gib(3_000_100, 0, 0); - assert!( - (plan.largest_block_ram_gib - floor).abs() < 1e-9, - "floor {} != closure-based {}", - plan.largest_block_ram_gib, - floor, - ); - } - - #[test] - fn aiur_flags_infeasible_atomic_block() { - // One block so hot its lone predicted RAM exceeds the cap: emitted alone, - // flagged infeasible. - let mut b = ProfileBuilder::new(); - b.block(addr(1), u64::MAX / 2, 1000, 1, ops(1000)); - b.block(addr(2), 10, 1000, 1, ops(0)); - let p = with_refs(b.finish(), &[vec![], vec![]]); - let plan = partition_for_aiur_ram(&p, 8.0, 0.05); - assert!(plan.infeasible_atomic_floor, "oversized atomic block must flag"); - } - #[test] fn ref_graph_roundtrips_through_ixprof() { let mut b = ProfileBuilder::new(); @@ -3378,77 +2564,6 @@ mod tests { assert_eq!(p, q); } - #[test] - fn rebudget_splits_one_shard_and_copies_the_rest_verbatim() { - // Six-block env, two natural clusters; pack everything into few shards - // at a large budget, then rebudget one shard at a small one. The other - // shards' block lists must be byte-identical (that identity is what - // keeps their cached proofs valid), and the new manifest must cover - // the same blocks with the split shard's children appended. - let mut b = ProfileBuilder::new(); - for i in 1..=6u8 { - b.block(addr(i), 2_000, 1_000, 1, ops(5_000_000)); - } - let p = - with_refs(b.finish(), &[vec![], vec![], vec![], vec![], vec![], vec![]]); - let dir = std::env::temp_dir(); - let pid = std::process::id(); - let prof = dir.join(format!("ix_rebudget_{pid}.ixprof")); - let m0 = dir.join(format!("ix_rebudget_{pid}.ixes")); - let m1 = dir.join(format!("ix_rebudget_{pid}_split.ixes")); - std::fs::write(&prof, p.to_bytes()).unwrap(); - // Budget picked so the 6 blocks pack into 2-3 shards (composed base - // ~19.7 GiB + ~18.6 GiB marginal per block at subst 5e6). - shard_esp_aiur( - prof.to_str().unwrap(), - 100.0, - 0.05, - 1, - Some(m0.to_str().unwrap()), - ) - .unwrap(); - let before = - ShardManifest::from_bytes(&std::fs::read(&m0).unwrap()).unwrap(); - assert!(before.shards.len() >= 2, "fixture must pack multiple shards"); - // Split shard 0 at a smaller budget so it must break into children. - let report = rebudget_manifest_shard( - prof.to_str().unwrap(), - m0.to_str().unwrap(), - 0, - 60.0, - 0.05, - m1.to_str().unwrap(), - ) - .unwrap(); - let after = - ShardManifest::from_bytes(&std::fs::read(&m1).unwrap()).unwrap(); - assert!(after.shards.len() > before.shards.len(), "report: {report}"); - for s in 1..before.shards.len() { - assert_eq!( - after.shards[s].blocks, before.shards[s].blocks, - "untouched shard {s} must be copied verbatim" - ); - } - // Cover preserved: same multiset of owned blocks overall. - let owned = |m: &ShardManifest| { - let mut v: Vec
= - m.shards.iter().flat_map(|s| s.blocks.iter().cloned()).collect(); - v.sort(); - v - }; - assert_eq!(owned(&before), owned(&after)); - // Sidecar exists with one row per shard. - let csv = - std::fs::read_to_string(format!("{}.costs.csv", m1.to_str().unwrap())) - .unwrap(); - assert_eq!(csv.lines().count(), after.shards.len() + 1); - for f in [&prof, &m0, &m1] { - let _ = std::fs::remove_file(f); - } - let _ = std::fs::remove_file(format!("{}.costs.csv", m0.to_str().unwrap())); - let _ = std::fs::remove_file(format!("{}.costs.csv", m1.to_str().unwrap())); - } - #[test] fn shard_esp_file_roundtrip() { // Exercise the CLI's shard path: write a .ixprof, run shard_esp, read back From 806e9bc6b45dd0c6904490031978e05bdae0fbc8 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Wed, 5 Aug 2026 21:16:33 +0000 Subject: [PATCH 12/20] scan: systemd-run worker caps, order-file startup, retuned pool plan MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Worker memory caps move from hand-managed cgroup dirs to systemd-run --user --scope -p MemoryMax (MemorySwapMax=0): a session-scoped parent cannot migrate children into the user-service subtree itself (common-ancestor rule), so the manual cgroup.procs attach never actually took effect and workers ran silently uncapped — the 3 GiB-free incident on the FLT fleet. The user manager performs the migration over D-Bus and garbage-collects the scopes; the manual CgroupBase machinery is deleted. Availability is probed once per pool and its absence is a loud UNCAPPED warning. Verified with a starved-cap run: kernel SIGKILLs at every over-cap batch, per-block narrowing recovers, full coverage. Children read the parent's derived schedule from an order file (IX_SCAN_ORDER_FILE env; addresses + min-cut order; deleted when the pool drops) instead of each re-deriving it — 30 workers re-running the FLT bisection concurrently was minutes of pure startup. The pool plan gains honest slack: fraction 0.72 with a 12 GiB OS reserve on top of the measured parent baseline, and a 6 GiB cap floor that bounds the auto worker count, so every child brushing its cap simultaneously still leaves tens of GiB free. --- crates/ffi/src/aiur/scan.rs | 296 +++++++++++++++++++++++------------- 1 file changed, 190 insertions(+), 106 deletions(-) diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index 4b0d30310..1bd197127 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -265,6 +265,32 @@ const SCAN_BATCH_BLOCKS: usize = 128; /// bounds the record and the cap only fires on mid-claim growth. const WORKER_OVERHEAD_GIB: f64 = 4.0; +/// Fraction of box RAM the worker pool may plan against, with +/// [`OS_RESERVE_GIB`] subtracted on top of the measured parent baseline. +/// Sized so that every child brushing its cap simultaneously plus the +/// parent plus OS/page-cache still leaves tens of GiB free (an 0.85 +/// plan measured 3 GiB free at the FLT fleet's high-water — too close). +const POOL_RAM_FRAC: f64 = 0.72; +const OS_RESERVE_GIB: f64 = 12.0; + +/// Smallest useful child cap; also bounds the auto worker count +/// (`pool / floor`), so caps never shrink below what a segment's +/// overhead needs. +const WORKER_CAP_FLOOR_GIB: f64 = 6.0; + +/// Auto worker counts shrink until every child's even share of the pool +/// clears the cap floor; explicit counts and thread mode pass through. +fn bound_workers_by_pool(workers: usize, pool_gib: f64, proc: bool) -> usize { + if !proc { + return workers; + } + let by_floor: usize = + format!("{:.0}", (pool_gib / WORKER_CAP_FLOOR_GIB).floor()) + .parse() + .unwrap_or(1); + workers.min(by_floor.max(1)).max(1) +} + /// The min-cut schedule order, truncated by the `IX_SCAN_LIMIT_BLOCKS` /// debug knob (a full-pipeline reproducer over a slice of a huge env, /// without extracting one; the result then does NOT cover the env). @@ -437,8 +463,19 @@ pub fn scan_worker( ) -> Result<(), String> { use std::io::{BufRead, Write}; let toplevel = system.toplevel(); - let (blocks, adj) = schedule_blocks(env); - let order = ordered_schedule(&blocks, &adj, pieces); + // The parent already derived the schedule; children read it from the + // order file instead of re-deriving (30 children re-running the + // min-cut bisection concurrently was minutes of pure startup on + // FLT-scale envs). Fallback to self-derivation keeps the worker + // usable standalone. + let (blocks, order) = match std::env::var("IX_SCAN_ORDER_FILE") { + Ok(path) => read_order_file(&path)?, + Err(_) => { + let (blocks, adj) = schedule_blocks(env); + let order = ordered_schedule(&blocks, &adj, pieces); + (blocks, order) + }, + }; let failed: Mutex> = Mutex::new(Vec::new()); let abort = std::sync::atomic::AtomicBool::new(false); let ctx = ScanCtx { @@ -504,6 +541,66 @@ pub fn scan_worker( Ok(()) } +/// Serialize the derived schedule for worker children: block addresses +/// (in block-id order) and the min-cut order. Members and sizes are +/// parent-side concerns (chunking, manifest assembly) — a worker needs +/// only `id → addr` for claims and the order for range indexing. +fn write_order_file( + path: &std::path::Path, + blocks: &[SchedBlock], + order: &[u32], +) -> Result<(), String> { + let mut buf: Vec = + Vec::with_capacity(16 + blocks.len() * 32 + order.len() * 4); + buf.extend_from_slice(&(blocks.len() as u64).to_le_bytes()); + for b in blocks { + buf.extend_from_slice(b.addr.as_bytes()); + } + buf.extend_from_slice(&(order.len() as u64).to_le_bytes()); + for &o in order { + buf.extend_from_slice(&o.to_le_bytes()); + } + std::fs::write(path, buf).map_err(|e| format!("write {path:?}: {e}")) +} + +fn read_order_file(path: &str) -> Result<(Vec, Vec), String> { + let buf = + std::fs::read(path).map_err(|e| format!("read order file {path}: {e}"))?; + let take_u64 = |buf: &[u8], pos: usize| -> Result { + buf + .get(pos..pos + 8) + .and_then(|b| b.try_into().ok()) + .map(u64::from_le_bytes) + .ok_or_else(|| format!("order file {path}: truncated")) + }; + let nblocks = usize::try_from(take_u64(&buf, 0)?) + .map_err(|_e| "order file: block count overflow".to_string())?; + let mut pos = 8; + let mut blocks = Vec::with_capacity(nblocks); + for _ in 0..nblocks { + let addr = buf + .get(pos..pos + 32) + .and_then(|b| Address::from_slice(b).ok()) + .ok_or_else(|| format!("order file {path}: truncated address"))?; + blocks.push(SchedBlock { addr, members: Vec::new(), size: 0 }); + pos += 32; + } + let norder = usize::try_from(take_u64(&buf, pos)?) + .map_err(|_e| "order file: order count overflow".to_string())?; + pos += 8; + let mut order = Vec::with_capacity(norder); + for _ in 0..norder { + let v = buf + .get(pos..pos + 4) + .and_then(|b| b.try_into().ok()) + .map(u32::from_le_bytes) + .ok_or_else(|| format!("order file {path}: truncated order"))?; + order.push(v); + pos += 4; + } + Ok((blocks, order)) +} + fn hex_encode(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } @@ -517,61 +614,16 @@ fn hex_decode(s: &str) -> Option> { .collect() } -/// Per-run cgroup-v2 management under the user-delegated subtree. Every -/// worker gets its own leaf with `memory.max` (the hard cap) and -/// `memory.oom.group=1` (an over-cap worker dies whole, never -/// half-alive). Best-effort: `None` anywhere means caps are unavailable -/// (no delegation) and the pool runs uncapped with a warning. -struct CgroupBase { - dir: std::path::PathBuf, -} - -impl CgroupBase { - fn create() -> Option { - let uid = std::fs::read_to_string("/proc/self/status") - .ok()? - .lines() - .find_map(|l| l.strip_prefix("Uid:"))? - .split_whitespace() - .next()? - .to_string(); - let dir = std::path::PathBuf::from(format!( - "/sys/fs/cgroup/user.slice/user-{uid}.slice/user@{uid}.service/ix-scan-{}", - std::process::id() - )); - std::fs::create_dir(&dir).ok()?; - Some(Self { dir }) - } - - fn child(&self, name: &str, cap_bytes: u64) -> Option { - let d = self.dir.join(name); - // A respawned worker reuses its slot's cgroup: tolerate the existing - // dir and rewrite the cap, so replacements stay capped. - match std::fs::create_dir(&d) { - Ok(()) => {}, - Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}, - Err(_) => return None, - } - std::fs::write(d.join("memory.max"), format!("{cap_bytes}")).ok()?; - // Best-effort: kill the whole worker on OOM, not one thread. - let _ = std::fs::write(d.join("memory.oom.group"), "1"); - Some(d) - } - - fn attach(dir: &std::path::Path, pid: u32) -> bool { - std::fs::write(dir.join("cgroup.procs"), format!("{pid}")).is_ok() - } -} - -impl Drop for CgroupBase { - fn drop(&mut self) { - if let Ok(entries) = std::fs::read_dir(&self.dir) { - for e in entries.flatten() { - let _ = std::fs::remove_dir(e.path()); - } - } - let _ = std::fs::remove_dir(&self.dir); - } +/// Whether `systemd-run --user --scope` is available to enforce +/// per-worker memory caps (the kernel migration a session-scoped process +/// cannot do itself, done by the user manager over D-Bus). Probed once +/// per pool; without it workers run uncapped with a loud warning. +fn systemd_scope_caps_available() -> bool { + std::process::Command::new("systemd-run") + .args(["--user", "--scope", "--quiet", "--", "true"]) + .status() + .map(|st| st.success()) + .unwrap_or(false) } /// Everything the process pool needs to spawn and command workers. @@ -590,7 +642,13 @@ struct ProcPool<'a> { /// fleet RAM only transiently and by design. pool_cap_bytes: u64, big_lane: Mutex<()>, - cgroups: Option, + /// The parent-derived schedule serialized for children (deleted when + /// the pool drops) — spawn startup is env-mmap + system build, not a + /// re-derivation. + order_file: std::path::PathBuf, + /// Caps are enforced via `systemd-run --user --scope -p MemoryMax=`; + /// false means the probe failed and workers run UNCAPPED. + capped: bool, order: &'a [u32], blocks: &'a [SchedBlock], fail_fast: bool, @@ -609,21 +667,43 @@ struct ScanReply { next: usize, } +impl Drop for ProcPool<'_> { + fn drop(&mut self) { + let _ = std::fs::remove_file(&self.order_file); + } +} + impl ProcPool<'_> { fn spawn(&self, slot: usize) -> Result { - self.spawn_capped(slot, self.cap_bytes, &format!("w{slot}")) + self.spawn_capped(slot, self.cap_bytes) } fn spawn_capped( &self, slot: usize, cap_bytes: u64, - cg_name: &str, ) -> Result { use std::process::{Command, Stdio}; - let mut cmd = Command::new(&self.bin); + let mut cmd = if self.capped { + let mut c = Command::new("systemd-run"); + c.args([ + "--user", + "--scope", + "--quiet", + "-p", + &format!("MemoryMax={cap_bytes}"), + "-p", + "MemorySwapMax=0", + "--", + &self.bin, + ]); + c + } else { + Command::new(&self.bin) + }; cmd .arg("shard-worker") + .env("IX_SCAN_ORDER_FILE", &self.order_file) .args(["--ixe", &self.ixe]) .args(["--cut-gib", &format!("{}", self.cut_used_gib)]) .args(["--batch", &format!("{}", self.batch_blocks)]) @@ -637,14 +717,6 @@ impl ProcPool<'_> { let mut child = cmd .spawn() .map_err(|e| format!("spawn worker {slot} ({}): {e}", self.bin))?; - if let Some(cg) = &self.cgroups { - match cg.child(cg_name, cap_bytes) { - Some(dir) if CgroupBase::attach(&dir, child.id()) => {}, - _ => { - eprintln!("[scan] worker {slot}: cgroup attach failed; UNCAPPED"); - }, - } - } let stdin = child.stdin.take().expect("piped stdin"); let stdout = std::io::BufReader::new(child.stdout.take().expect("piped stdout")); @@ -914,14 +986,13 @@ fn run_pool_procs( // falsely excluded by its slot's even share. let big_reply = { let _lane = pool.big_lane.lock().unwrap(); - pool - .spawn_capped(slot, pool.pool_cap_bytes, "big") - .ok() - .map(|mut big| { + pool.spawn_capped(slot, pool.pool_cap_bytes).ok().map( + |mut big| { let r = pool.scan(&mut big, b, b + 1); big.reap(); r - }) + }, + ) }; match big_reply { Some(Ok(reply)) => { @@ -1018,6 +1089,9 @@ pub fn execute_env( } else { workers }; + // Provisional: re-bounded by pool/cap-floor once the measured + // baseline is known (proc mode only). + let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") .ok() .and_then(|v| v.parse::().ok()) @@ -1035,11 +1109,13 @@ pub fn execute_env( // the residency the worker fleet's record budget sits on top of. let baseline_gib = process_rss_gib(); let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - // Thread-mode record drop: each worker's even share of the measured - // headroom — segments cut (and drop their record) when they reach it. - let record_cut_gib = (ram.mul_add(0.85, -baseline_gib - 2.0) - / f64_from_usize(workers)) - .clamp(4.0, 64.0); + let pool_gib = + ram.mul_add(POOL_RAM_FRAC, -(baseline_gib + OS_RESERVE_GIB)).max(8.0); + let workers = + bound_workers_by_pool(workers, pool_gib, proc_workers.is_some()); + // Record drop: each worker's even share of the measured headroom — + // segments cut (and drop their record) when they reach it. + let record_cut_gib = (pool_gib / f64_from_usize(workers)).clamp(4.0, 64.0); let n_chunks = (workers * 2).min(blocks.len()); eprintln!( "[exec] {} blocks, {workers} workers over {n_chunks} chunks, record \ @@ -1069,20 +1145,24 @@ pub fn execute_env( // on segment size, so width goes to the core count and the cap is // whatever the pool affords per worker — smaller segments cost // only a few percent of cold-boundary work. - let pool_gib = ram.mul_add(0.85, -baseline_gib - 2.0).max(8.0); - let cap_gib = (pool_gib / f64_from_usize(workers)).clamp(6.0, 64.0); + let cap_gib = + (pool_gib / f64_from_usize(workers)).clamp(WORKER_CAP_FLOOR_GIB, 64.0); let soft_gib = (cap_gib - WORKER_OVERHEAD_GIB).max(cap_gib / 2.0); - let cgroups = CgroupBase::create(); - if cgroups.is_none() { + let capped = systemd_scope_caps_available(); + if !capped { eprintln!( - "[exec] cgroup delegation unavailable — workers run UNCAPPED" + "[exec] systemd-run --user scopes unavailable — workers run \ + UNCAPPED" ); } eprintln!( "[exec] process pool: {workers} workers, {cap_gib:.1} GiB cap \ each{}", - if cgroups.is_some() { " (cgroup memory.max)" } else { "" } + if capped { " (systemd MemoryMax)" } else { "" } ); + let order_file = std::env::temp_dir() + .join(format!("ix-scan-order-{}.bin", std::process::id())); + write_order_file(&order_file, &blocks, &order)?; let pool = ProcPool { bin: bin.to_string(), ixe: ixe.to_string(), @@ -1092,14 +1172,10 @@ pub fn execute_env( pieces: sched_pieces, exec_only: true, cap_bytes: gib_to_bytes_u64(cap_gib), - pool_cap_bytes: gib_to_bytes_u64( - crate::kernel::system_ram_gib() - .unwrap_or(64.0) - .mul_add(0.85, -baseline_gib - 2.0) - .max(8.0), - ), + pool_cap_bytes: gib_to_bytes_u64(pool_gib), big_lane: Mutex::new(()), - cgroups, + order_file, + capped, order: &order, blocks: &blocks, fail_fast, @@ -1184,6 +1260,9 @@ pub fn scan_shards( } else { workers }; + // Provisional: re-bounded by pool/cap-floor once the measured + // baseline is known (proc mode only). + let batch_blocks = std::env::var("IX_SCAN_BATCH_BLOCKS") .ok() .and_then(|v| v.parse::().ok()) @@ -1206,13 +1285,18 @@ pub fn scan_shards( // Content denser than the cap is a per-block event: the cgroup kill // names it, and the big-lane retry (whole-pool cap, serialized) rescues // blocks that are heavy but provable. + let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); + let pool_gib = + ram.mul_add(POOL_RAM_FRAC, -(baseline_gib + OS_RESERVE_GIB)).max(8.0); + let workers = + bound_workers_by_pool(workers, pool_gib, proc_workers.is_some()); let proc_cap_gib = proc_workers.map(|_| { - let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - let pool_gib = ram.mul_add(0.85, -baseline_gib - 2.0).max(8.0); std::env::var("IX_SCAN_WORKER_CAP_GIB") .ok() .and_then(|v| v.parse::().ok()) - .unwrap_or_else(|| (pool_gib / f64_from_usize(workers)).clamp(6.0, 64.0)) + .unwrap_or_else(|| { + (pool_gib / f64_from_usize(workers)).clamp(WORKER_CAP_FLOOR_GIB, 64.0) + }) }); let n_chunks = (workers * 2).min(blocks.len()); eprintln!( @@ -1244,16 +1328,20 @@ pub fn scan_shards( Some((bin, ixe)) => { let cap_gib = proc_cap_gib.unwrap_or(16.0); let soft_gib = (cap_gib - WORKER_OVERHEAD_GIB).max(cap_gib / 2.0); - let cgroups = CgroupBase::create(); - if cgroups.is_none() { + let order_file = std::env::temp_dir() + .join(format!("ix-scan-order-{}.bin", std::process::id())); + write_order_file(&order_file, &blocks, &order)?; + let capped = systemd_scope_caps_available(); + if !capped { eprintln!( - "[scan] cgroup delegation unavailable — workers run UNCAPPED" + "[scan] systemd-run --user scopes unavailable — workers run \ + UNCAPPED" ); } eprintln!( "[scan] process pool: {workers} workers, {cap_gib:.1} GiB cap \ each{}, soft record cut {soft_gib:.1} GiB", - if cgroups.is_some() { " (cgroup memory.max)" } else { "" }, + if capped { " (systemd MemoryMax)" } else { "" }, ); let pool = ProcPool { bin: bin.to_string(), @@ -1264,14 +1352,10 @@ pub fn scan_shards( pieces: sched_pieces, exec_only: false, cap_bytes: gib_to_bytes_u64(cap_gib), - pool_cap_bytes: gib_to_bytes_u64( - crate::kernel::system_ram_gib() - .unwrap_or(64.0) - .mul_add(0.85, -baseline_gib - 2.0) - .max(8.0), - ), + pool_cap_bytes: gib_to_bytes_u64(pool_gib), big_lane: Mutex::new(()), - cgroups, + order_file, + capped, order: &order, blocks: &blocks, fail_fast, From f0ee2a41115d709a7dd8b5ca767a1922fef347a2 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Wed, 5 Aug 2026 21:39:05 +0000 Subject: [PATCH 13/20] scan: bound the big lane by remaining headroom, not the pool MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A big-lane retry capped at the whole pool could overcommit the box while the regular fleet sits at its caps (observed: a monster measurement at 34 GiB atop a 151 GiB fleet drove used memory to 245 GiB). The big cap is now the derived remainder — ram minus the fleet pool minus the measured baseline and OS reserve (~70 GiB here) — which still measures every provable-at-budget block; only content beyond that headroom is named infeasible. --- crates/ffi/src/aiur/scan.rs | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index 1bd197127..c85e19378 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -1172,7 +1172,13 @@ pub fn execute_env( pieces: sched_pieces, exec_only: true, cap_bytes: gib_to_bytes_u64(cap_gib), - pool_cap_bytes: gib_to_bytes_u64(pool_gib), + // The BIG lane's cap is the headroom that remains when every + // slot is at its cap — never the pool itself, which would let a + // big measurement plus a full fleet overcommit the box. + pool_cap_bytes: gib_to_bytes_u64( + (ram - pool_gib - baseline_gib - OS_RESERVE_GIB) + .max(2.0 * WORKER_CAP_FLOOR_GIB), + ), big_lane: Mutex::new(()), order_file, capped, @@ -1352,7 +1358,13 @@ pub fn scan_shards( pieces: sched_pieces, exec_only: false, cap_bytes: gib_to_bytes_u64(cap_gib), - pool_cap_bytes: gib_to_bytes_u64(pool_gib), + // The BIG lane's cap is the headroom that remains when every + // slot is at its cap — never the pool itself, which would let a + // big measurement plus a full fleet overcommit the box. + pool_cap_bytes: gib_to_bytes_u64( + (ram - pool_gib - baseline_gib - OS_RESERVE_GIB) + .max(2.0 * WORKER_CAP_FLOOR_GIB), + ), big_lane: Mutex::new(()), order_file, capped, From 1b177e06434be0c7472ab48f419fe2eba4d533a2 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Thu, 6 Aug 2026 00:34:55 +0000 Subject: [PATCH 14/20] scan: drop the cold retry; size caps for a cold first batch MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A capped worker's death is self-caused and deterministic (measured 244/246 same-index re-deaths on FLT): retrying the range re-executes exactly the batch that proved too big, paying the most expensive claim in the pipeline to learn nothing. Death now narrows the dying batch immediately, deleting the retry state. The cap floor rises 6 -> 9 GiB, sized for the real constraint the FLT run measured: a fresh segment's opening claim re-derives its shared dependencies cold, a ~4-7 GiB working set on dense content. Below that, kill-and-narrow was the common case — 490 deaths and ~39% of all execution spent re-measuring narrowed units — instead of the rare one. Fewer, fatter workers (pool/9) with cold batches that fit. --- crates/ffi/src/aiur/scan.rs | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index c85e19378..072dbc79b 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -276,7 +276,12 @@ const OS_RESERVE_GIB: f64 = 12.0; /// Smallest useful child cap; also bounds the auto worker count /// (`pool / floor`), so caps never shrink below what a segment's /// overhead needs. -const WORKER_CAP_FLOOR_GIB: f64 = 6.0; +/// Sized so a COLD first batch fits: a fresh segment's opening claim +/// re-derives its shared dependencies in one execution, and on dense +/// content (FLT) that working set measured ~4-7 GiB — a 6 GiB floor made +/// the kill-and-narrow path the common case (490 deaths, ~39% of all +/// execution spent on narrowing) instead of the rare one. +const WORKER_CAP_FLOOR_GIB: f64 = 9.0; /// Auto worker counts shrink until every child's even share of the pool /// clears the cap floor; explicit counts and thread mode pass through. @@ -880,7 +885,6 @@ fn run_pool_procs( continue; }; let mut cursor = lo; - let mut retried_at: Option = None; let commit = |reply: ScanReply, origin: u32, seq: u32| -> Result { if !reply.segs.is_empty() { @@ -948,9 +952,12 @@ fn run_pool_procs( "[scan] worker {slot} died ({status}) at index {e}; \ respawned" ); - if retried_at == Some(e) { - // Second death with zero progress: narrow one batch - // window with unit ranges to name the culprit. + { + // A capped worker's death is self-caused and (measured + // 244/246 on FLT) deterministic — retrying the same + // range re-executes exactly the batch that proved too + // big. Narrow the dying batch immediately: unit ranges + // name the culprit or measure it on the big lane. let window = (e + pool.batch_blocks).min(hi); let mut b = e; while b < window { @@ -1034,10 +1041,6 @@ fn run_pool_procs( b += 1; } cursor = window; - retried_at = None; - } else { - retried_at = Some(e); - cursor = e; } }, } From 93df5fca48ed875fd4e7a50c29ac9998a1006912 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Thu, 6 Aug 2026 15:34:22 +0000 Subject: [PATCH 15/20] scan: exact record accounting; slice-derived sizing; continue-on-death MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The QueryRecord is the only structure that grows during a scan (env caches parse without storing), so memory control anchors on it exactly: QueryMap::heap_bytes() counts arena fill, stored hashes, and the hash table's allocation, and record_heap_bytes() is the worker's segment-cut threshold. record_retained_bytes stays as the analytic prove-RAM model's record term — the two intentionally differ (the model is calibrated end-to-end against measured proves). Worker sizing derives from the box in one pass: pool = RAM - parent baseline - OS reserve - a reserved big-lane budget; width = cores - 2 while each even slice clears a 5 GiB floor; the slice is the systemd cap and the record cut is the slice minus the worker baseline and one claim's worst-case growth. Claims shrink 128 -> 32 blocks so that mid-claim growth (~4 GiB per 128 dense blocks, scaling with K) fits the headroom; the measurement drift sits between the measured +3.7% (K=64) and +11.6% (K=16), and drift only overstates costs. Death handling loses the span ladder: a kill is record growth, not claim width, so the fresh worker continues full-width from the committed index (replaying a range from its start re-accumulates the same record and dies at the same index; narrowed claims poisoned the tail by killing every warm worker that touched them). A block with two zero-progress attempts is measured once on the serialized big lane or named resource-infeasible. RSS reads survive only in heartbeats and the parent's one-time baseline measurement — never in control flow. Arena accounting counts fill, never reserved capacity: rounding open segments to hugepage granules put ~3.4 GiB of phantom bytes on the threshold across a few hundred touched maps and fragmented Init into 2423 segments (2.8x wall regression) before the fill-only fix. Init @ 250: 82.1 s wall, 30 workers x 6.3 GiB slices, record cut 3.3 GiB, 0 deaths, 111 raw segments -> 64 shards, max predicted prove RSS 231.1 GiB vs the 232.8 cut. --- crates/aiur/src/execute.rs | 15 ++ crates/aiur/src/querymap.rs | 29 +++ crates/ffi/src/aiur/scan.rs | 488 ++++++++++++++++++------------------ 3 files changed, 294 insertions(+), 238 deletions(-) diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index acc9ebc2b..68ea1c30e 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -379,6 +379,21 @@ pub fn record_retained_bytes(record: &QueryRecord) -> usize { elems * 8 + entries * 21 } +/// Exact resident heap of the record's query maps (arena fill at hugepage +/// granularity, stored hashes, hash-table allocations). This is the +/// scanner's record threshold metric — what the process actually holds +/// while executing. [`record_retained_bytes`] intentionally differs: it +/// is the analytic prove-RAM model's record term, calibrated end-to-end +/// against measured proves, and must not change with allocator details. +pub fn record_heap_bytes(record: &QueryRecord) -> usize { + record.function_queries.iter().map(QueryMap::heap_bytes).sum::() + + record + .memory_queries + .iter() + .map(|(_, m)| m.heap_bytes()) + .sum::() +} + pub fn record_fft_cost(toplevel: &Toplevel, record: &QueryRecord) -> f64 { const EXT_DEGREE: usize = 2; fn fft(w: usize, h: usize) -> f64 { diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 56f97306e..7ddb8b91f 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -194,6 +194,14 @@ impl SegStore { fn retained_elems(&self) -> usize { self.entries * self.stride } + + /// Heap bytes of the arena's fill. Segments are mmap-backed and fault + /// as they fill, so fill IS residency up to page granularity — never + /// count reserved-but-untouched capacity (a fresh segment per store + /// across hundreds of maps adds gigabytes of phantom bytes). + fn heap_bytes(&self) -> usize { + self.entries * self.stride * size_of::() + } } /// Segmented store of per-entry key hashes. Kept so hash-table growth can @@ -224,6 +232,11 @@ impl SegHashes { self.segs[seg].extend_from_slice(&[h]); self.entries += 1; } + + /// Heap bytes of the fill; same rule as [`SegStore::heap_bytes`]. + fn heap_bytes(&self) -> usize { + self.entries * size_of::() + } } /// Append-only query store with a hash index. @@ -282,6 +295,22 @@ impl QueryMap { self.keys.retained_elems() + self.outs.retained_elems() } + /// Exact heap bytes of this map's fill: arena elements, stored hashes, + /// and the hash-table allocation (power-of-two buckets at 7/8 load, + /// `u32` index + 1 control byte per bucket, fully resident). + pub fn heap_bytes(&self) -> usize { + let buckets = if self.table.capacity() == 0 { + 0 + } else { + (self.table.capacity() * 8 / 7 + 1).next_power_of_two() + }; + self.keys.heap_bytes() + + self.outs.heap_bytes() + + self.mults.heap_bytes() + + self.hashes.heap_bytes() + + buckets * (size_of::() + 1) + } + pub fn get_index_of(&self, key: &[G]) -> Option { debug_assert_eq!(key.len(), self.keys.stride); let hash = hash_g_slice(key); diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index 072dbc79b..74b259f0a 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -57,7 +57,7 @@ use aiur::{ bytecode::Toplevel, execute::{ IOBuffer, QueryRecord, dump_query_stats, f64_from_usize, - query_stats_enabled, record_fft_cost, record_retained_bytes, + query_stats_enabled, record_fft_cost, record_heap_bytes, }, synthesis::AiurSystem, }; @@ -253,46 +253,57 @@ struct ScanCtx<'a> { /// Default blocks per measurement claim; `IX_SCAN_BATCH_BLOCKS` /// overrides (1 restores per-block claims). Fixed — never adaptive — so -/// the partition stays independent of scheduling. Sized from the -/// measured inflation curve on Init (drift vs one-cold-claim re-priced -/// costs: K=16 +11.6%, K=64 +3.7%, K=128 +0.9%): at 128 the running -/// readout is within the cut's ε margin, so it serves directly as the -/// manifest cost. -const SCAN_BATCH_BLOCKS: usize = 128; +/// the partition stays independent of scheduling. The claim is also the +/// granularity of the record-threshold check, so its worst-case record +/// growth must fit inside [`CLAIM_HEADROOM_GIB`]: dense FLT content +/// measured ~4 GiB of growth per 128-block claim, scaling roughly with +/// K. K=32 bounds that to ~1 GiB at a conservative measurement drift +/// between the measured +3.7% (K=64) and +11.6% (K=16) — drift only +/// overstates costs, tightening the plan, never breaking it. +const SCAN_BATCH_BLOCKS: usize = 32; -/// A worker child's non-record residency: lazily-decoded env cache, -/// compiled system, runtime. Reserved under the cap so the soft cut -/// bounds the record and the cap only fires on mid-claim growth. -const WORKER_OVERHEAD_GIB: f64 = 4.0; +/// Target blocks per work-queue chunk. Chunks are the unit of stealing: +/// once fewer chunks remain than workers, the excess workers idle — the +/// serial tail is bounded by the largest chunk, so chunks must be much +/// finer than the worker count (workers×2 on FLT left 16 of 18 workers +/// idle for the last third of the scan). Chunk edges are forced segment +/// boundaries; the merge pass absorbs the extra fragmentation. +const CHUNK_TARGET_BLOCKS: usize = 2048; -/// Fraction of box RAM the worker pool may plan against, with -/// [`OS_RESERVE_GIB`] subtracted on top of the measured parent baseline. -/// Sized so that every child brushing its cap simultaneously plus the -/// parent plus OS/page-cache still leaves tens of GiB free (an 0.85 -/// plan measured 3 GiB free at the FLT fleet's high-water — too close). -const POOL_RAM_FRAC: f64 = 0.72; -const OS_RESERVE_GIB: f64 = 12.0; +/// A worker's non-record residency: env mmap, compiled AiurSystem, +/// runtime (fresh workers measured ~1.2-1.8 GiB on FLT). +const WORKER_BASELINE_GIB: f64 = 2.0; + +/// Worst single-claim record growth past the threshold check (the check +/// runs between claims): ~4 GiB per 128-block claim measured on dense +/// FLT content, scaling roughly with [`SCAN_BATCH_BLOCKS`] — ~1 GiB at +/// K=32. Calibrate against the first run on new content. +const CLAIM_HEADROOM_GIB: f64 = 1.0; -/// Smallest useful child cap; also bounds the auto worker count -/// (`pool / floor`), so caps never shrink below what a segment's -/// overhead needs. -/// Sized so a COLD first batch fits: a fresh segment's opening claim -/// re-derives its shared dependencies in one execution, and on dense -/// content (FLT) that working set measured ~4-7 GiB — a 6 GiB floor made -/// the kill-and-narrow path the common case (490 deaths, ~39% of all -/// execution spent on narrowing) instead of the rare one. -const WORKER_CAP_FLOOR_GIB: f64 = 9.0; +/// Smallest useful per-worker slice: baseline + claim headroom + enough +/// record threshold to make progress. Bounds the auto worker count +/// (`pool / floor`). +const SLICE_FLOOR_GIB: f64 = 5.0; -/// Auto worker counts shrink until every child's even share of the pool -/// clears the cap floor; explicit counts and thread mode pass through. +/// Reserved for the serialized BIG worker that measures blocks unable to +/// start under a normal slice; carved out of the pool up front so the +/// fleet bound `Σ slices + big lane ≤ pool` holds by construction. +const BIG_LANE_GIB: f64 = 48.0; + +/// Subtracted from box RAM (with the measured parent baseline) before +/// slicing the pool: kernel, page cache churn, and everything else on +/// the box that is not this scan. +const OS_RESERVE_GIB: f64 = 12.0; + +/// Auto worker counts shrink until every child's even slice of the pool +/// clears the slice floor; explicit counts and thread mode pass through. fn bound_workers_by_pool(workers: usize, pool_gib: f64, proc: bool) -> usize { if !proc { return workers; } - let by_floor: usize = - format!("{:.0}", (pool_gib / WORKER_CAP_FLOOR_GIB).floor()) - .parse() - .unwrap_or(1); + let by_floor: usize = format!("{:.0}", (pool_gib / SLICE_FLOOR_GIB).floor()) + .parse() + .unwrap_or(1); workers.min(by_floor.max(1)).max(1) } @@ -448,8 +459,8 @@ fn run_pool( /// emitted segment (absolute order indices), `SKIP /// ` per kernel-rejected block, then `END ` (`next == /// hi` when the range is exhausted). A unit range (`hi == lo+1`) -/// degenerates to a single-block claim — the parent narrows a dying -/// batch by sending unit ranges, no dedicated verb needed. +/// degenerates to a single-block claim — the parent's BIG lane +/// measures an unstartable block this way, no dedicated verb needed. /// /// The worker never applies fail-fast itself — it reports SKIPs and the /// parent enforces policy. RAM: the enclosing cgroup's `memory.max` is @@ -823,35 +834,49 @@ impl WorkerHandle { } /// Process-pool scan: like [`run_pool`], but each worker is a separate -/// `ix shard-worker` process under a cgroup memory cap — a worker whose -/// record outgrows its cap mid-claim is OOM-killed ALONE, and the parent -/// recovers: retry the remainder once (transient collisions), then -/// narrow the dying batch with unit ranges to name the exact block as -/// resource-infeasible-at-cap and scan on. The fleet's RAM bound is -/// `Σ caps`, enforced by the kernel, independent of content. +/// `ix shard-worker` process under a cgroup memory cap. A worker's env +/// decode cache grows monotonically with the content it executes (the +/// record drops at segment cuts; the cache never shrinks), so on dense +/// content every worker periodically fills its cap and is OOM-killed — +/// death IS the cache-shedding mechanism, and it is cheap: segments +/// stream as they close, so a kill loses only the work since the last +/// closed segment. The parent respawns and continues from the committed +/// index; the fresh cache carries it until the next shed. A block that +/// yields zero progress twice in a row cannot even START under the slot +/// cap — that one block is measured on the BIG lane (whole-pool cap) or +/// named resource-infeasible. The fleet's RAM bound is `Σ caps`, +/// enforced by the kernel, independent of content. fn run_pool_procs( pool: &ProcPool<'_>, chunks: Vec<(usize, usize)>, workers: usize, failed: &Mutex>, ) -> Result, String> { - type Range = (u32, u32, usize, usize); + // (origin chunk, commit sequence, lo, hi, stalls): `stalls` counts + // consecutive deaths at `lo` with zero committed progress — two in a + // row means the block at `lo` cannot even start under the slot cap. + type Range = (u32, u32, usize, usize, u8); + let total_blocks: usize = chunks.iter().map(|(lo, hi)| hi - lo).sum(); + let start = std::time::Instant::now(); let queue: Mutex> = Mutex::new( chunks .into_iter() .enumerate() .map(|(i, (lo, hi))| { - (u32::try_from(i).expect("chunk count fits u32"), 0u32, lo, hi) + (u32::try_from(i).expect("chunk count fits u32"), 0u32, lo, hi, 0u8) }) .collect(), ); let in_flight = AtomicUsize::new(0); + let blocks_done = AtomicUsize::new(0); + let last_pct = AtomicUsize::new(0); let done: Mutex)>> = Mutex::new(Vec::new()); let failure: Mutex> = Mutex::new(None); let abort = std::sync::atomic::AtomicBool::new(false); std::thread::scope(|s| { let (queue, in_flight, done, failure, abort) = (&queue, &in_flight, &done, &failure, &abort); + let (blocks_done, last_pct) = (&blocks_done, &last_pct); for slot in 0..workers { s.spawn(move || { let mut worker = match pool.spawn(slot) { @@ -865,7 +890,51 @@ fn run_pool_procs( return; }, }; - 'work: loop { + // Monotonic committed-block count; one line per percent crossed. + let progress = |n: usize| { + if n == 0 { + return; + } + let d = blocks_done.fetch_add(n, Ordering::AcqRel) + n; + let pct = d * 100 / total_blocks.max(1); + if pct > last_pct.fetch_max(pct, Ordering::AcqRel) { + eprintln!( + "[scan] {d}/{total_blocks} blocks ({pct}%), {:.0}s", + start.elapsed().as_secs_f64() + ); + } + }; + let commit = + |reply: ScanReply, origin: u32, seq: u32| -> Result { + if !reply.segs.is_empty() { + done.lock().unwrap().push(((origin, seq), reply.segs)); + } + if !reply.skips.is_empty() { + let fatal = pool.fail_fast; + let first = reply.skips.first().cloned(); + failed.lock().unwrap().extend(reply.skips); + if fatal { + if let Some((a, e)) = first { + let mut f = failure.lock().unwrap(); + if f.is_none() { + *f = Some(format!( + "CheckEnv of block {} failed during scan: {e} \ + (--no-fail-fast records and skips such blocks)", + a.hex() + )); + } + } + return Err(()); + } + } + Ok(reply.next) + }; + let requeue = |origin: u32, seq: u32, lo: usize, hi: usize, stalls| { + if lo < hi { + queue.lock().unwrap().push_back((origin, seq, lo, hi, stalls)); + } + }; + loop { if abort.load(Ordering::Acquire) { break; } @@ -877,173 +946,117 @@ fn run_pool_procs( } popped }; - let Some((origin, seq, lo, hi)) = next else { + let Some((origin, seq, lo, hi, stalls)) = next else { if in_flight.load(Ordering::Acquire) == 0 { break; } std::thread::sleep(std::time::Duration::from_millis(50)); continue; }; - let mut cursor = lo; - let commit = - |reply: ScanReply, origin: u32, seq: u32| -> Result { - if !reply.segs.is_empty() { - done.lock().unwrap().push(((origin, seq), reply.segs)); - } - if !reply.skips.is_empty() { - let fatal = pool.fail_fast; - let first = reply.skips.first().cloned(); - failed.lock().unwrap().extend(reply.skips); - if fatal { - if let Some((a, e)) = first { + match pool.scan(&mut worker, lo, hi) { + Ok(reply) => { + let Ok(next) = commit(reply, origin, seq) else { + abort.store(true, Ordering::Release); + break; + }; + progress(next.saturating_sub(lo)); + requeue(origin, seq + 1, next, hi, 0); + }, + Err(partial) => { + let e = match commit(partial, origin, seq) { + Ok(n) => n, + Err(()) => { + abort.store(true, Ordering::Release); + break; + }, + }; + progress(e.saturating_sub(lo)); + let status = std::mem::replace( + &mut worker, + match pool.spawn(slot) { + Ok(w) => w, + Err(err) => { let mut f = failure.lock().unwrap(); if f.is_none() { - *f = Some(format!( - "CheckEnv of block {} failed during scan: {e} \ - (--no-fail-fast records and skips such blocks)", - a.hex() - )); + *f = Some(err); } - } - return Err(()); - } - } - Ok(reply.next) - }; - while cursor < hi { - if abort.load(Ordering::Acquire) { - break 'work; - } - match pool.scan(&mut worker, cursor, hi) { - Ok(reply) => { - let Ok(next) = commit(reply, origin, seq) else { - abort.store(true, Ordering::Release); - break 'work; - }; - if next < hi { - queue.lock().unwrap().push_back((origin, seq + 1, next, hi)); - } - break; - }, - Err(partial) => { - let e = match commit(partial, origin, seq) { - Ok(n) => n, - Err(()) => { abort.store(true, Ordering::Release); - break 'work; - }, - }; - let status = std::mem::replace( - &mut worker, - match pool.spawn(slot) { - Ok(w) => w, - Err(err) => { - let mut f = failure.lock().unwrap(); - if f.is_none() { - *f = Some(err); - } - abort.store(true, Ordering::Release); - break 'work; - }, + break; }, - ) - .reap(); + }, + ) + .reap(); + if e >= hi { + eprintln!( + "[scan] worker {slot} died ({status}) after completing \ + its range; respawned" + ); + } else if e > lo || stalls < 1 { + // A cache-shed kill: the fresh worker continues from the + // committed index. `e == lo` earns one fresh-worker + // attempt before block `e` is treated as unstartable. + let stalls = if e > lo { 0 } else { stalls + 1 }; eprintln!( "[scan] worker {slot} died ({status}) at index {e}; \ - respawned" + respawned, continuing" ); - { - // A capped worker's death is self-caused and (measured - // 244/246 on FLT) deterministic — retrying the same - // range re-executes exactly the batch that proved too - // big. Narrow the dying batch immediately: unit ranges - // name the culprit or measure it on the big lane. - let window = (e + pool.batch_blocks).min(hi); - let mut b = e; - while b < window { - match pool.scan(&mut worker, b, b + 1) { - Ok(reply) => { - if commit(reply, origin, seq).is_err() { - abort.store(true, Ordering::Release); - break 'work; - } - }, - Err(partial) => { - let _ = commit(partial, origin, seq); - let addr = - pool.blocks[pool.order[b] as usize].addr.clone(); - let status = std::mem::replace( - &mut worker, - match pool.spawn(slot) { - Ok(w) => w, - Err(err) => { - let mut f = failure.lock().unwrap(); - if f.is_none() { - *f = Some(err); - } - abort.store(true, Ordering::Release); - break 'work; - }, - }, - ) - .reap(); - // BIG-lane retry: one worker at a time gets the - // whole pool as its cap, so a block that is - // heavy-but-provable measures instead of being - // falsely excluded by its slot's even share. - let big_reply = { - let _lane = pool.big_lane.lock().unwrap(); - pool.spawn_capped(slot, pool.pool_cap_bytes).ok().map( - |mut big| { - let r = pool.scan(&mut big, b, b + 1); - big.reap(); - r - }, - ) - }; - match big_reply { - Some(Ok(reply)) => { - if commit(reply, origin, seq).is_err() { - abort.store(true, Ordering::Release); - break 'work; - } - eprintln!( - "[scan] block {} exceeded its slot cap \ - ({status}) but measured on the big lane", - addr.hex() - ); - }, - other => { - if let Some(Err(partial2)) = other { - let _ = commit(partial2, origin, seq); - } - eprintln!( - "[scan] block {} exceeded the worker memory \ - cap ({status}) and the big lane — \ - resource-infeasible; skipped", - addr.hex() - ); - failed.lock().unwrap().push(( - addr, - format!( - "record outgrew the {:.1} GiB whole-pool \ - cap mid-claim (cgroup OOM-kill)", - f64_from_usize( - usize::try_from(pool.pool_cap_bytes) - .unwrap_or(usize::MAX) - ) / GIB - ), - )); - }, - } - }, + requeue(origin, seq + 1, e, hi, stalls); + } else { + // Two consecutive zero-progress deaths: block `e` cannot + // even start under the slot cap. BIG-lane retry: one + // worker at a time gets the whole pool as its cap, so a + // block that is heavy-but-provable measures instead of + // being falsely excluded by its slot's even share. + let addr = pool.blocks[pool.order[e] as usize].addr.clone(); + let big_reply = { + let _lane = pool.big_lane.lock().unwrap(); + pool.spawn_capped(slot, pool.pool_cap_bytes).ok().map( + |mut big| { + let r = pool.scan(&mut big, e, e + 1); + big.reap(); + r + }, + ) + }; + match big_reply { + Some(Ok(reply)) => { + if commit(reply, origin, seq).is_err() { + abort.store(true, Ordering::Release); + break; } - b += 1; - } - cursor = window; + eprintln!( + "[scan] block {} exceeded its slot cap ({status}) \ + but measured on the big lane", + addr.hex() + ); + }, + other => { + if let Some(Err(partial2)) = other { + let _ = commit(partial2, origin, seq); + } + eprintln!( + "[scan] block {} exceeded the worker memory cap \ + ({status}) and the big lane — resource-infeasible; \ + skipped", + addr.hex() + ); + failed.lock().unwrap().push(( + addr, + format!( + "record outgrew the {:.1} GiB whole-pool cap \ + mid-claim (cgroup OOM-kill)", + f64_from_usize( + usize::try_from(pool.pool_cap_bytes) + .unwrap_or(usize::MAX) + ) / GIB + ), + )); + }, } - }, - } + progress(1); + requeue(origin, seq + 1, e + 1, hi, 0); + } + }, } in_flight.fetch_sub(1, Ordering::AcqRel); } @@ -1112,14 +1125,22 @@ pub fn execute_env( // the residency the worker fleet's record budget sits on top of. let baseline_gib = process_rss_gib(); let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - let pool_gib = - ram.mul_add(POOL_RAM_FRAC, -(baseline_gib + OS_RESERVE_GIB)).max(8.0); + // Fleet bound by construction: Σ worker slices + big lane + parent + + // OS reserve = box RAM. Width goes to the core count when the pool + // affords a floor slice per worker. + let pool_gib = (ram - baseline_gib - OS_RESERVE_GIB - BIG_LANE_GIB) + .max(SLICE_FLOOR_GIB); let workers = bound_workers_by_pool(workers, pool_gib, proc_workers.is_some()); - // Record drop: each worker's even share of the measured headroom — - // segments cut (and drop their record) when they reach it. - let record_cut_gib = (pool_gib / f64_from_usize(workers)).clamp(4.0, 64.0); - let n_chunks = (workers * 2).min(blocks.len()); + // Record drop: each worker's even slice of the pool — segments cut + // (and drop their record) when the record's exact heap reaches it. + let record_cut_gib = (pool_gib / f64_from_usize(workers)) + - WORKER_BASELINE_GIB + - CLAIM_HEADROOM_GIB; + let record_cut_gib = record_cut_gib.max(1.0); + let n_chunks = (blocks.len() / CHUNK_TARGET_BLOCKS) + .max(workers * 2) + .min(blocks.len()); eprintln!( "[exec] {} blocks, {workers} workers over {n_chunks} chunks, record \ drop at {record_cut_gib:.1} GiB, {batch_blocks} blocks per claim", @@ -1144,13 +1165,8 @@ pub fn execute_env( }; let segments = match proc_workers { Some((bin, ixe)) => { - // Fastest wall without OOM: execution has no prove-cut constraint - // on segment size, so width goes to the core count and the cap is - // whatever the pool affords per worker — smaller segments cost - // only a few percent of cold-boundary work. - let cap_gib = - (pool_gib / f64_from_usize(workers)).clamp(WORKER_CAP_FLOOR_GIB, 64.0); - let soft_gib = (cap_gib - WORKER_OVERHEAD_GIB).max(cap_gib / 2.0); + let cap_gib = pool_gib / f64_from_usize(workers); + let soft_gib = record_cut_gib; let capped = systemd_scope_caps_available(); if !capped { eprintln!( @@ -1175,13 +1191,9 @@ pub fn execute_env( pieces: sched_pieces, exec_only: true, cap_bytes: gib_to_bytes_u64(cap_gib), - // The BIG lane's cap is the headroom that remains when every - // slot is at its cap — never the pool itself, which would let a - // big measurement plus a full fleet overcommit the box. - pool_cap_bytes: gib_to_bytes_u64( - (ram - pool_gib - baseline_gib - OS_RESERVE_GIB) - .max(2.0 * WORKER_CAP_FLOOR_GIB), - ), + // The BIG lane's budget is reserved out of the pool up front, so + // a big measurement plus a full fleet never overcommits the box. + pool_cap_bytes: gib_to_bytes_u64(BIG_LANE_GIB), big_lane: Mutex::new(()), order_file, capped, @@ -1288,26 +1300,28 @@ pub fn scan_shards( // the residency the worker pool's budget sits on top of. let baseline_gib = process_rss_gib(); // Width-first sizing, uniform for every env and budget: full-core - // width, and each worker's cap is its even share of the pool. Segments - // cut at the additive soft ceiling below the cap, so the budget only - // sets the MERGE target — scan wall never depends on the prove budget. - // Content denser than the cap is a per-block event: the cgroup kill - // names it, and the big-lane retry (whole-pool cap, serialized) rescues - // blocks that are heavy but provable. + // width, each worker's cap its even slice of the pool, and the record + // threshold (exact heap bytes) set so baseline + one claim's growth + // still fits under the cap — the kernel kill is a backstop, not the + // routine mechanism. The prove budget only sets the CUT and the merge + // target; scan wall never depends on it. Blocks too heavy for a slice + // escalate to the reserved big lane (serialized) or are named. let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - let pool_gib = - ram.mul_add(POOL_RAM_FRAC, -(baseline_gib + OS_RESERVE_GIB)).max(8.0); + // Fleet bound by construction: Σ worker slices + big lane + parent + + // OS reserve = box RAM. + let pool_gib = (ram - baseline_gib - OS_RESERVE_GIB - BIG_LANE_GIB) + .max(SLICE_FLOOR_GIB); let workers = bound_workers_by_pool(workers, pool_gib, proc_workers.is_some()); let proc_cap_gib = proc_workers.map(|_| { std::env::var("IX_SCAN_WORKER_CAP_GIB") .ok() .and_then(|v| v.parse::().ok()) - .unwrap_or_else(|| { - (pool_gib / f64_from_usize(workers)).clamp(WORKER_CAP_FLOOR_GIB, 64.0) - }) + .unwrap_or_else(|| pool_gib / f64_from_usize(workers)) }); - let n_chunks = (workers * 2).min(blocks.len()); + let n_chunks = (blocks.len() / CHUNK_TARGET_BLOCKS) + .max(workers * 2) + .min(blocks.len()); eprintln!( "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut at \ {cut_used_gib:.1} GiB predicted prove RSS (margin \ @@ -1336,7 +1350,8 @@ pub fn scan_shards( let segments = match proc_workers { Some((bin, ixe)) => { let cap_gib = proc_cap_gib.unwrap_or(16.0); - let soft_gib = (cap_gib - WORKER_OVERHEAD_GIB).max(cap_gib / 2.0); + let soft_gib = + (cap_gib - WORKER_BASELINE_GIB - CLAIM_HEADROOM_GIB).max(1.0); let order_file = std::env::temp_dir() .join(format!("ix-scan-order-{}.bin", std::process::id())); write_order_file(&order_file, &blocks, &order)?; @@ -1361,13 +1376,9 @@ pub fn scan_shards( pieces: sched_pieces, exec_only: false, cap_bytes: gib_to_bytes_u64(cap_gib), - // The BIG lane's cap is the headroom that remains when every - // slot is at its cap — never the pool itself, which would let a - // big measurement plus a full fleet overcommit the box. - pool_cap_bytes: gib_to_bytes_u64( - (ram - pool_gib - baseline_gib - OS_RESERVE_GIB) - .max(2.0 * WORKER_CAP_FLOOR_GIB), - ), + // The BIG lane's budget is reserved out of the pool up front, so + // a big measurement plus a full fleet never overcommits the box. + pool_cap_bytes: gib_to_bytes_u64(BIG_LANE_GIB), big_lane: Mutex::new(()), order_file, capped, @@ -1623,7 +1634,7 @@ fn scan_range( break (hi, prev_fft, prev_ram); } let fft = record_fft_cost(ctx.toplevel, &record); - let rec_gib = f64_from_usize(record_retained_bytes(&record)) / GIB; + let rec_gib = f64_from_usize(record_heap_bytes(&record)) / GIB; // The cut measure: for the scan, the analytic peak-prove-RSS // prediction from the record's circuit shapes; for execute-only // segments (which exist only to bound the live record), the @@ -1671,7 +1682,7 @@ fn scan_range( eprintln!( "[scan {chunk_id}/{n_chunks}] segment: {} blocks, {:.2} BFFT, \ {:.1}G {}, {}/{} blocks done, {:.0}s, rss {:.0}G, arena {}M, \ - iomap {}k, rec {}M", + iomap {}k, rec {}M entries/{:.1}G heap", seg_end - lo, seg_fft / 1e9, seg_ram, @@ -1682,7 +1693,8 @@ fn scan_range( process_rss_gib(), arena_g / 1_000_000, io.map.len() / 1000, - rec_e / 1_000_000 + rec_e / 1_000_000, + f64_from_usize(record_heap_bytes(&record)) / GIB ); segments.push(Segment { blocks: chunk[lo..seg_end].to_vec(), From a06a5c18066c3466782f6938c4641b2389a779a4 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Fri, 7 Aug 2026 21:11:10 +0000 Subject: [PATCH 16/20] name-of: batch --addrs-file resolution over one env decode --- Ix/Cli/NameOfCmd.lean | 83 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 74 insertions(+), 9 deletions(-) diff --git a/Ix/Cli/NameOfCmd.lean b/Ix/Cli/NameOfCmd.lean index 1a5e80d8a..074a36472 100644 --- a/Ix/Cli/NameOfCmd.lean +++ b/Ix/Cli/NameOfCmd.lean @@ -60,22 +60,86 @@ def nameLookup (ixonEnv : Ixon.Env) (addr : Address) : IO UInt32 := do return 1 return 0 +/-- Batch resolution: one env decode + one pass building both reverse + indexes (address → names, block → projection names), then O(1) per + address — the single-address path's per-call full scans cost ~90 s + each at FLT scale, which forbids inventories of tens of thousands. + Each address resolves to `[,…]` (`prj:` prefix for + projection fallbacks into unnamed blocks, `` for + misses). -/ +def resolveAddrs (ixonEnv : Ixon.Env) (addrs : Array Address) : + Array (Address × String) := Id.run do + let mut byAddr : Std.HashMap Address (Array String) := {} + for (n, named) in ixonEnv.named do + byAddr := byAddr.insert named.addr + ((byAddr.getD named.addr #[]).push (toString (ixNameToLeanName n))) + let mut byBlock : Std.HashMap Address (Array String) := {} + for (caddr, lc) in ixonEnv.consts do + let some c := lc.get? | continue + let blk? := match c.info with + | .iPrj p => some p.block + | .cPrj p => some p.block + | .rPrj p => some p.block + | .dPrj p => some p.block + | _ => none + if let some blk := blk? then + let nm := match ixonEnv.getName? caddr with + | some n => toString (ixNameToLeanName n) + | none => s!"" + byBlock := byBlock.insert blk ((byBlock.getD blk #[]).push nm) + let mut out : Array (Address × String) := #[] + for a in addrs do + let disp := match byAddr.get? a with + | some ns => String.intercalate "," ns.toList + | none => match byBlock.get? a with + | some ns => s!"prj:{String.intercalate "," ns.toList}" + | none => "" + out := out.push (a, disp) + return out + +def batchLookup (ixonEnv : Ixon.Env) (addrs : Array Address) : IO UInt32 := do + let resolved := resolveAddrs ixonEnv addrs + let mut missing := 0 + for (a, disp) in resolved do + IO.println s!"{a} {disp}" + if disp == "" then + missing := missing + 1 + if missing > 0 then + IO.eprintln s!"[name-of] {missing} address(es) unresolved" + return 0 + def runNameOfCmd (p : Cli.Parsed) : IO UInt32 := do - let some addrArg := p.positionalArg? "addr" - | p.printError "error: must specify a 64-char hex address"; return 1 - let argStr := addrArg.as! String - let some addr := Address.fromString argStr - | IO.eprintln s!"error: `{argStr}` is not a 64-char hex address" - return 1 let some path := (p.flag? "ixe").map (·.as! String) | IO.eprintln "error: name-of requires --ixe " return 1 + let batchFile := (p.flag? "addrs-file").map (·.as! String) + let addrArgs := p.variableArgsAs! String + if batchFile.isNone && addrArgs.isEmpty then + p.printError "error: pass a 64-char hex address or --addrs-file" + return 1 let bytes ← IO.FS.readBinFile path let ixonEnv ← match Ixon.deEnvAnon bytes with | .error e => IO.eprintln s!"error: failed to deserialize {path}: {e}"; return 1 | .ok env => pure env - nameLookup ixonEnv addr + match batchFile with + | some file => + let mut addrs : Array Address := #[] + for line in (← IO.FS.readFile file).splitOn "\n" do + let line := line.trimAscii.toString + if line.isEmpty || line.startsWith "#" then + continue + let some a := Address.fromString line + | IO.eprintln s!"error: `{line}` is not a 64-char hex address" + return 1 + addrs := addrs.push a + batchLookup ixonEnv addrs + | none => + let argStr := addrArgs[0]! + let some addr := Address.fromString argStr + | IO.eprintln s!"error: `{argStr}` is not a 64-char hex address" + return 1 + nameLookup ixonEnv addr end Ix.Cli.NameOfCmd @@ -85,10 +149,11 @@ def nameOfCmd : Cli.Cmd := `[Cli| "Resolve a content address back to its Lean name(s) in a `.ixe` env (may print several: structurally equivalent constants share an address)" FLAGS: - "ixe" : String; "Path to a serialized `.ixe` env to resolve the address in (required)." + "ixe" : String; "Path to a serialized `.ixe` env to resolve the address in (required)." + "addrs-file" : String; "Batch mode: file of 64-char hex addresses (one per line; `#` comments and blanks ignored). One env decode resolves them all — output ` [,…]` per line, `prj:` prefix for projection fallbacks." ARGS: - addr : String; "64-char hex content address to resolve. Prints every Lean.Name registered for it, one per line; for unnamed Muts blocks, prints the names of projection constants into the block instead." + ...addr : String; "64-char hex content address to resolve (omit when using --addrs-file). Prints every Lean.Name registered for it, one per line; for unnamed Muts blocks, prints the names of projection constants into the block instead." ] end From 19fea11b387f1fd77799f2f516930dac4f999830 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Fri, 7 Aug 2026 21:11:10 +0000 Subject: [PATCH 17/20] scan: growth-derived claims, worker recycling, --defer-infeasible naming, opt-in cold re-price, exec-only workers --- Ix/Cli/ShardCmd.lean | 71 ++- crates/ffi/src/aiur/scan.rs | 1107 +++++++++++++++++++++++++++++------ 2 files changed, 989 insertions(+), 189 deletions(-) diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index 4284bee7a..9daa256af 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -45,6 +45,7 @@ public import Ix.IxVM.Toplevel public import Ix.KernelCheck public import Ix.TracingTexray public import Ix.Cli.ConstsFile +public import Ix.Cli.NameOfCmd public section @@ -71,6 +72,18 @@ def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do if noFailFast && p.hasFlag "fail-fast" then p.printError "error: --fail-fast and --no-fail-fast are mutually exclusive" return 1 + -- Deferred ranges (regions whose opening cone exceeds a fleet slot — + -- cone-bound kernel execution measured at hours of worker time on + -- FLT/Mathlib-class content) are named infeasible instead of walked + -- under fat caps, and the exclusion inventory is resolved to Lean + -- names in `.failed-names.txt`. Implies --no-fail-fast; the + -- mode reaches the scanner as fail-fast mode string "2". + let deferInfeasible := p.hasFlag "defer-infeasible" + -- Cold re-price (opt-in): replace summed shard costs with one + -- measured cold execution per merged shard, packing past the cut by + -- the validated slack. Adopt per env only after its re-priced + -- manifest passes the heaviest-shard prove protocol. + let reprice := p.hasFlag "reprice" let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 | .ok t => pure t @@ -86,11 +99,14 @@ def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do let workersDesc := if workers == 0 then "auto" else toString workers IO.println s!"Scanning {ixePath} @ {budget} GiB (ε {eps}%, {workersDesc} workers)" (← IO.getStdout).flush - -- `benchJson = (out, rowName)` reports the scan as a benchmark row (the - -- `aiur-shard` bench backend): `scan-time` windows the scan itself — the - -- env mmap and toplevel build are excluded, so the measure tracks the - -- kernel execution, not the loader — while `peak-rss` is the process - -- tree's absolute high-water, matching the check rows' semantics. + -- `benchJson = (out, rowName)` reports the scan as a benchmark row + -- (the `aiur` bench backend's whole-env execute row): the scan IS a + -- whole-env execution — the cut on top of it is an in-memory merge + -- over the collected block records — so the wall reports as + -- `execute-time`, windowing the scan itself: the env mmap and + -- toplevel build are excluded, so the measure tracks the kernel + -- execution, not the loader. `peak-rss` is the process tree's + -- absolute high-water, matching the check rows' semantics. let benchJson := (p.flag? "json").map fun f => (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "scan") if benchJson.isSome then @@ -109,15 +125,47 @@ def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do let workerBin := (← IO.appPath).toString match Aiur.AiurSystem.scanShardsWithEnv system funIdx envHandle (toString budget) (toString eps) (toString workers) - (if noFailFast then "0" else "1") outPath workerBin ixePath with + (if deferInfeasible && reprice then "4" + else if reprice then "3" + else if deferInfeasible then "2" + else if noFailFast then "0" + else "1") + outPath workerBin ixePath with | .ok () => if let some (out, rowName) := benchJson then let secs := ((← IO.monoMsNow) - start).toFloat / 1000.0 let peakRss ← TracingTexray.peakTreeRssBytes Ix.Benchmark.Results.writeRow out rowName "ok" - [ ("scan-time", Ix.Benchmark.Results.jsonRound 3 secs) + [ ("execute-time", Ix.Benchmark.Results.jsonRound 3 secs) , ("peak-rss", Lean.toJson peakRss) ] IO.println s!"[shard scan] wrote {outPath} (+ .costs.csv, measured)" + -- Resolve the exclusion inventory to Lean names: one env decode + + -- batch reverse-index lookup (`ix name-of --addrs-file` semantics), + -- so a shard run over dense content ends with a readable list of + -- exactly which constants were excluded and why. + if deferInfeasible then + let failedPath := outPath ++ ".failed.csv" + if ← System.FilePath.pathExists failedPath then + let mut addrs : Array Address := #[] + for line in (← IO.FS.readFile failedPath).splitOn "\n" do + let addrStr := (line.splitOn ",").headD "" + if let some a := Address.fromString addrStr then + addrs := addrs.push a + if !addrs.isEmpty then + let bytes ← IO.FS.readBinFile ixePath + match Ixon.deEnvAnon bytes with + | .error e => + IO.eprintln s!"[shard scan] failed-names resolution skipped: {e}" + | .ok ixonEnv => + let resolved := + Ix.Cli.NameOfCmd.resolveAddrs ixonEnv addrs + let namesPath := outPath ++ ".failed-names.txt" + let lines := resolved.map fun (a, disp) => s!"{a} {disp}" + IO.FS.writeFile namesPath + (String.intercalate "\n" lines.toList ++ "\n") + IO.println + s!"[shard scan] {addrs.size} excluded block(s) resolved → \ + {namesPath}" return 0 | .error e => IO.eprintln s!"error: shard scan failed: {e}" @@ -260,7 +308,9 @@ def runShardWorkerCmd (p : Cli.Parsed) : IO UInt32 := do | .ok h => pure h match Aiur.AiurSystem.scanWorker system funIdx envHandle cutGib (toString batch) softCap (toString pieces) - (if p.hasFlag "exec-only" then "1" else "0") with + (if p.hasFlag "defer-growth" then "2" + else if p.hasFlag "exec-only" then "1" + else "0") with | .ok () => return 0 | .error e => IO.eprintln s!"shard-worker: {e}"; return 1 @@ -279,7 +329,9 @@ def shardCmd : Cli.Cmd := `[Cli| workers : Nat; "Scan only: parallel chunk scanners (default 0 = autoscale to cores and detected RAM). Each holds one segment's query record and faulted witness, so workers × segment footprint must fit the box" "fail-fast"; "Scan: halt on the first kernel-rejected block (the default; flag accepted for explicitness)." "no-fail-fast"; "Scan: skip kernel-rejected blocks (named as skipped, excluded from the partition, listed in .failed.csv). The manifest then does not cover them — the downstream coverage gate reports exactly which." - json : String; "Scan only: benchmark results JSON accumulator — append a `scan-time`/`peak-rss` row. Used by `ix bench run --backend aiur-shard`." + "reprice"; "Scan: cold re-price — pack past the cut on summed costs, then measure each merged shard's true cost with one cold CheckEnv execution (splits over-cut shards). Opt-in; validate per env by proving the heaviest re-priced shard before adopting its manifest." + "defer-infeasible"; "Scan: name deferred dense regions (opening cone exceeds a fleet slot) resource-infeasible instead of walking them under fat caps, and resolve the whole exclusion inventory to Lean names in .failed-names.txt. Implies --no-fail-fast. The partition covers only tractable content; failed.csv + failed-names.txt carry the exact boundary." + json : String; "Scan only: benchmark results JSON accumulator — append an `execute-time`/`peak-rss` row (the scan wall is a whole-env execution wall). Used by `ix bench run --backend aiur` for the whole-env execute row." "json-name" : String; "Row name for --json (default: scan)." shards : Nat; ".ixprof only: fixed number of shards N (overrides the budget sizing)" "max-cycles" : Nat; ".ixprof only: per-shard guest-cycle budget (overrides the RAM sizing)" @@ -305,6 +357,7 @@ def shardWorkerCmd : Cli.Cmd := `[Cli| "soft-cap-gib" : String; "Graceful record ceiling, GiB — segments cut here so only mid-claim growth reaches the cgroup kill" pieces : Nat; "Schedule piece count (must match the parent's chunking)" "exec-only"; "Execute-only mode: record-bytes cut, no prove model" + "defer-growth"; "Execute-only phase 1: hand dense range remainders back (DEFER) when measured record growth per block crosses the phase threshold; implies --exec-only" ] end diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index 74b259f0a..2bbea07a3 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -241,6 +241,10 @@ struct ScanCtx<'a> { /// execute-only mode, where the cut is the record's retained bytes /// against the per-worker share. system: Option<&'a AiurSystem>, + /// Execute-only phase 1: defer a range's remainder to the fat phase + /// when measured record growth per block exceeds this (bytes). + /// `None` disables (the scan, and the fat phase itself). + defer_growth: Option, /// Graceful record ceiling, GiB: a segment also cuts when its record's /// retained bytes reach this, independent of the model cut. In /// cgroup-capped worker processes it sits below the enforced cap @@ -271,32 +275,105 @@ const SCAN_BATCH_BLOCKS: usize = 32; const CHUNK_TARGET_BLOCKS: usize = 2048; /// A worker's non-record residency: env mmap, compiled AiurSystem, -/// runtime (fresh workers measured ~1.2-1.8 GiB on FLT). -const WORKER_BASELINE_GIB: f64 = 2.0; +/// runtime (fresh workers measured ~1.2-1.8 GiB on FLT), PLUS working +/// room for the env decode cache, which grows monotonically with +/// content touched (death is its shedding mechanism — but it must not +/// be the routine one, so the slot budgets a few GiB of cache first). +const WORKER_BASELINE_GIB: f64 = 3.5; -/// Worst single-claim record growth past the threshold check (the check -/// runs between claims): ~4 GiB per 128-block claim measured on dense -/// FLT content, scaling roughly with [`SCAN_BATCH_BLOCKS`] — ~1 GiB at -/// K=32. Calibrate against the first run on new content. +/// Target record growth per claim, GiB. Claim width K derives from it +/// (see [`scan_range`]): K = target / measured-growth-per-block, clamped +/// to `[1, SCAN_BATCH_BLOCKS]`. Per-claim overhead (assumption-tree +/// hashing, unshared `env_walk` frames) is roughly constant per claim, +/// so it is negligible against a claim carrying this much work — light +/// content runs at full width where the overhead would bite, dense +/// content shrinks to K=1-2 where each block dwarfs it. Bounding growth +/// per claim is what lets the between-claims threshold check act before +/// the cgroup kill on ANY content. +const CLAIM_TARGET_GIB: f64 = 0.75; + +/// Worst mid-claim record growth past the threshold check: with claim +/// width derived from [`CLAIM_TARGET_GIB`], overshoot beyond the target +/// is one block's excess over its range's running estimate — bounded in +/// practice by the single-block record distribution's body; the tail +/// (true monster blocks) is the deferred cleanup's job, not headroom's. const CLAIM_HEADROOM_GIB: f64 = 1.0; -/// Smallest useful per-worker slice: baseline + claim headroom + enough -/// record threshold to make progress. Bounds the auto worker count -/// (`pool / floor`). -const SLICE_FLOOR_GIB: f64 = 5.0; +/// Smallest useful per-worker slice: the soft record cut (the segment +/// measurement quantum, ~11.5 GiB at this floor — segments are summed +/// to the cut by the merge pass, so they never need to reach it alone) +/// plus the cache-inclusive worker baseline and one claim's headroom. +/// Bounds the auto worker count (`pool / floor`). Measured across the +/// FLT sweep: 8 GiB slots (60 workers) and 12 GiB slots (33 workers) +/// both ground down in the dense head — cache + a useful record quantum +/// simply need this much — while ~17-18 GiB slots ran it best; thinner +/// buys width the dense content immediately claws back in deaths. +const SLICE_FLOOR_GIB: f64 = 16.0; + +/// Width of the deferred-block cleanup round: blocks whose own claim +/// died under a slot cap re-run after the fleet drains, each worker +/// capped at the freed pool split this many ways (~65-70 GiB on the +/// deliverable boxes). Sized from the monster-record distribution: +/// every escalated block ever measured except two fit under ~70 GiB, +/// so a wider round would trade slots that fit the population for +/// parallelism the survivors cannot use. +const CLEANUP_WORKERS: usize = 12; + +/// Execute-only phase-1 deferral threshold: record growth per block +/// (bytes) above which a range's remainder is handed to the fat-slot +/// phase instead of walked thin. The measured distribution is bimodal +/// with a decade-wide gap (light content ~1-20 MB/block, dense +/// typeclass-web content ~300 MB-4 GiB/block), so any threshold in the +/// gap classifies robustly, and both error directions are cheap: an +/// over-deferred range walks warm in phase 2; an under-deferred one +/// triggers on its next claim. Growth is measured, not predicted — +/// record growth IS the reduction work just performed. +const DEFER_GROWTH_BYTES_PER_BLOCK: f64 = 1.0e8; + +/// Merge-pass packing target as a multiple of the cut. Summed segment +/// costs overstate a merged shard's true cold cost (shared cones count +/// once per segment; padded heights are subadditive) — measured +/// true/summed = 0.606-0.623 on the three heaviest 500-budget shards — +/// so packing to the cut on sums leaves ~40% of the budget unused. The +/// merge packs past the cut by this factor and the cold RE-PRICE round +/// then measures every shard's true cost (one CheckEnv execution per +/// shard, the exact claim its prove runs); the deliberate gap below the +/// measured 1.6x slack keeps over-cut re-prices (which force a split) +/// rare. +const PACK_OVERSHOOT: f64 = 1.45; + +/// Re-price round width: one cold execution per merged shard, each +/// holding only the shard's RECORD (~true prove RSS / 20), so slots are +/// pool/width ≈ 30-40 GiB — enough for every shard record plus a dense +/// opening cone. +const REPRICE_WORKERS: usize = 12; -/// Reserved for the serialized BIG worker that measures blocks unable to -/// start under a normal slice; carved out of the pool up front so the -/// fleet bound `Σ slices + big lane ≤ pool` holds by construction. -const BIG_LANE_GIB: f64 = 48.0; +/// Ranges a child serves before the parent proactively reaps and +/// respawns it. The env decode cache grows monotonically with content +/// touched — measured ~2-4 GiB per DENSE range — so recycling bounds +/// every child's cache to about one range's growth: slot headroom +/// belongs to the RECORD at every point in the schedule, dense strips +/// walk inline at fleet width, and mid-strip deaths (whose resume +/// points cannot re-open under a slot and would push whole strip +/// remainders into the narrow cleanup round) stay rare. Spawn cost is +/// seconds (order file + env mmap) against tens of seconds per range. +const WORKER_RECYCLE_RANGES: usize = 2; /// Subtracted from box RAM (with the measured parent baseline) before /// slicing the pool: kernel, page cache churn, and everything else on /// the box that is not this scan. const OS_RESERVE_GIB: f64 = 12.0; -/// Auto worker counts shrink until every child's even slice of the pool -/// clears the slice floor; explicit counts and thread mode pass through. +/// Fraction of the derived pool actually sliced into worker caps. The +/// caps are a worst-case bound and dense regions reach it: on FLT's +/// head every worker sits near its cap simultaneously, so `Σ caps = +/// pool` runs the box to zero free (measured: 490/495 GB used, page +/// cache evicted to zero). The unsliced remainder is the fleet's slack — +/// all workers brushing their caps at once still leave it free. +const POOL_SLICE_FRAC: f64 = 0.85; + +/// Worker counts shrink until every child's even slice of the pool +/// clears the slice floor; thread mode passes through. fn bound_workers_by_pool(workers: usize, pool_gib: f64, proc: bool) -> usize { if !proc { return workers; @@ -307,15 +384,31 @@ fn bound_workers_by_pool(workers: usize, pool_gib: f64, proc: bool) -> usize { workers.min(by_floor.max(1)).max(1) } -/// The min-cut schedule order, truncated by the `IX_SCAN_LIMIT_BLOCKS` -/// debug knob (a full-pipeline reproducer over a slice of a huge env, -/// without extracting one; the result then does NOT cover the env). +/// The min-cut schedule order, windowed by the `IX_SCAN_SKIP_BLOCKS` / +/// `IX_SCAN_LIMIT_BLOCKS` debug knobs (a full-pipeline reproducer over a +/// slice of a huge env, without extracting one; the result then does NOT +/// cover the env). Skip drops the order's head, limit truncates what +/// remains — composed, they select any window; skip alone replays the +/// schedule's TAIL, where min-cut ordering concentrates the dense +/// content that dominates scan wall. fn ordered_schedule( blocks: &[SchedBlock], adj: &[Vec], n_chunks: usize, ) -> Vec { let mut order = static_order(blocks, adj, n_chunks.max(16)); + if let Some(skip) = std::env::var("IX_SCAN_SKIP_BLOCKS") + .ok() + .and_then(|v| v.parse::().ok()) + .filter(|&n| n > 0) + { + let skip = skip.min(order.len()); + eprintln!( + "[scan] IX_SCAN_SKIP_BLOCKS={skip}: executing a schedule SUFFIX — \ + the result will not cover the env" + ); + order.drain(..skip); + } if let Some(limit) = std::env::var("IX_SCAN_LIMIT_BLOCKS") .ok() .and_then(|v| v.parse::().ok()) @@ -330,9 +423,19 @@ fn ordered_schedule( order } -/// Equal-byte contiguous chunks over the order; edges are forced segment -/// boundaries (the parallelism unit); the scan's merge pass repairs the -/// resulting fragmentation, so chunk count is a pure parallelism knob. +/// Blocks per chunk past which an edge is forced regardless of bytes. +/// Chunks are byte-balanced, but cost per byte is wildly non-uniform: +/// FLT's dense proof blocks are small in bytes and huge in cost, so +/// byte-only balancing packed up to ~3,100 of them into one chunk — +/// ~10 sequential cut-sized segments for a single owner, the measured +/// serial tail of the scan. The count clamp splits exactly those +/// chunks; the merge pass absorbs the extra forced boundaries. +const CHUNK_MAX_BLOCKS: usize = 512; + +/// Equal-byte contiguous chunks over the order, block-count clamped +/// (see [`CHUNK_MAX_BLOCKS`]); edges are forced segment boundaries (the +/// parallelism unit); the scan's merge pass repairs the resulting +/// fragmentation, so chunk granularity is a pure parallelism knob. fn make_chunk_bounds( order: &[u32], blocks: &[SchedBlock], @@ -345,7 +448,7 @@ fn make_chunk_bounds( let mut acc = 0u64; for (i, &b) in order.iter().enumerate() { acc += blocks[b as usize].size; - if acc >= per_chunk && bounds.len() + 1 < n_chunks { + if acc >= per_chunk || i + 1 - start >= CHUNK_MAX_BLOCKS { bounds.push((start, i + 1)); start = i + 1; acc = 0; @@ -415,7 +518,7 @@ fn run_pool( continue; }; match scan_range(ctx, &range, origin) { - Ok((segs, rest)) => { + Ok((segs, rest, _defer)) => { done.lock().unwrap().push(((origin, seq), segs)); // Remainder goes back BEFORE the in-flight decrement, so // `empty && in_flight == 0` still implies no future work. @@ -453,14 +556,18 @@ fn run_pool( /// parent and executing order-index ranges on command. Line protocol /// (one command per stdin line, replies on stdout): /// -/// - `SCAN ` — scan `order[lo..hi)` exactly like a thread -/// worker's range: up to [`RANGE_SEGMENTS`] segments, then hand the -/// remainder back. Replies: `SEG ` per -/// emitted segment (absolute order indices), `SKIP -/// ` per kernel-rejected block, then `END ` (`next == -/// hi` when the range is exhausted). A unit range (`hi == lo+1`) -/// degenerates to a single-block claim — the parent's BIG lane -/// measures an unstartable block this way, no dedicated verb needed. +/// - `SCAN [narrow]` — scan `order[lo..hi)` exactly like a +/// thread worker's range: up to [`RANGE_SEGMENTS`] segments, then hand +/// the remainder back. The optional `narrow` count single-steps the +/// range's first N blocks (one per claim) — sent by the parent when a +/// range resumes after a death so a dense stretch banks per-block +/// progress instead of re-dying at full claim width. Replies: +/// `SEG ` per emitted segment (absolute order +/// indices), `SKIP ` per kernel-rejected block, +/// then `END ` (`next == hi` when the range is exhausted). A +/// unit range (`hi == lo+1`) degenerates to a single-block claim — +/// the deferred-block cleanup round measures blocks this way, no +/// dedicated verb needed. /// /// The worker never applies fail-fast itself — it reports SKIPs and the /// parent enforces policy. RAM: the enclosing cgroup's `memory.max` is @@ -476,6 +583,7 @@ pub fn scan_worker( soft_record_gib: f64, pieces: usize, exec_only: bool, + defer_growth: bool, ) -> Result<(), String> { use std::io::{BufRead, Write}; let toplevel = system.toplevel(); @@ -494,6 +602,9 @@ pub fn scan_worker( }; let failed: Mutex> = Mutex::new(Vec::new()); let abort = std::sync::atomic::AtomicBool::new(false); + // Shard member lists for `PRICE`, loaded lazily on first use — most + // children never price. + let mut price_table: Option>> = None; let ctx = ScanCtx { toplevel, fun_idx, @@ -506,6 +617,7 @@ pub fn scan_worker( abort: &abort, batch_blocks, system: if exec_only { None } else { Some(system) }, + defer_growth: defer_growth.then_some(DEFER_GROWTH_BYTES_PER_BLOCK), soft_record_gib, }; let stdout = std::io::stdout(); @@ -521,6 +633,59 @@ pub fn scan_worker( it.next().and_then(|v| v.parse::().ok()), it.next().and_then(|v| v.parse::().ok()), ); + // A third field (a since-removed narrow-prefix hint) is accepted + // and ignored for wire compatibility with parents of that vintage. + let _ = it.next(); + if verb == "PRICE" { + // Cold re-price of one merged shard: execute its whole CheckEnv + // claim (the exact claim its prove runs) with a fresh record and + // report the record's measured fft plus the analytic peak prove + // RSS. `lo` is the shard index in the price file. + let Some(k) = lo else { + return Err(format!("worker: malformed command {line:?}")); + }; + if price_table.is_none() { + let path = std::env::var("IX_SCAN_PRICE_FILE") + .map_err(|_e| "worker: PRICE without IX_SCAN_PRICE_FILE")?; + price_table = Some(read_price_file(&path)?); + } + let table = price_table.as_ref().unwrap(); + let members = table + .get(k) + .ok_or_else(|| format!("worker: PRICE {k} out of range"))?; + let addrs: Vec
= members + .iter() + .map(|&b| blocks[b as usize].addr.clone()) + .collect(); + let mut record = QueryRecord::new(toplevel); + let mut io = + IOBuffer::with_backing(EnvFaultSource::new(env.clone())); + let priced = seed_shard_check_env_claim(env, &addrs, &mut io).and_then( + |(_claim, input)| { + execute_ixvm_with_record(toplevel, fun_idx, &input, &mut io, &mut record) + .map(|_| ()) + .map_err(|e| e.to_string()) + }, + ); + match priced { + Ok(()) => { + let fft = record_fft_cost(toplevel, &record); + let ram = match ctx.system { + Some(sys) => { + f64_from_usize(sys.peak_prove_bytes(&record).peak) / GIB + }, + None => f64_from_usize(record_heap_bytes(&record)) / GIB, + }; + writeln!(out, "COST {fft} {ram}").map_err(|e| e.to_string())?; + }, + Err(e) => { + writeln!(out, "PERR {}", hex_encode(e.as_bytes())) + .map_err(|e| e.to_string())?; + }, + } + out.flush().map_err(|e| e.to_string())?; + continue; + } let (Some(lo), Some(hi)) = (lo, hi) else { return Err(format!("worker: malformed command {line:?}")); }; @@ -530,7 +695,7 @@ pub fn scan_worker( match verb { "SCAN" => { let range = &order[lo..hi]; - let (segs, rest) = + let (segs, rest, deferred) = scan_range(&ctx, range, u32::try_from(lo).unwrap_or(0))?; // Segments consume the range in order; skipped blocks sit in the // gaps. Recover absolute bounds by cursor-matching first ids. @@ -548,7 +713,9 @@ pub fn scan_worker( writeln!(out, "SKIP {} {}", a.hex(), hex_encode(e.as_bytes())) .map_err(|e| e.to_string())?; } - writeln!(out, "END {}", hi - rest.len()).map_err(|e| e.to_string())?; + let verb = if deferred { "DEFER" } else { "END" }; + writeln!(out, "{verb} {}", hi - rest.len()) + .map_err(|e| e.to_string())?; }, _ => return Err(format!("worker: unknown verb {verb:?}")), } @@ -617,6 +784,60 @@ fn read_order_file(path: &str) -> Result<(Vec, Vec), String> { Ok((blocks, order)) } +/// Serialize merged shards' member block ids for the re-price workers: +/// `[u64 shard count][per shard: u64 len, u32 ids…]`. Members are block +/// ids into the order file's block table, so a worker prices exactly +/// the claim the manifest will carry (holes from skipped blocks +/// included). +fn write_price_file( + path: &std::path::Path, + shards: &[Vec], +) -> Result<(), String> { + let total: usize = shards.iter().map(Vec::len).sum(); + let mut buf: Vec = Vec::with_capacity(8 + shards.len() * 8 + total * 4); + buf.extend_from_slice(&(shards.len() as u64).to_le_bytes()); + for m in shards { + buf.extend_from_slice(&(m.len() as u64).to_le_bytes()); + for &b in m { + buf.extend_from_slice(&b.to_le_bytes()); + } + } + std::fs::write(path, buf).map_err(|e| format!("write {path:?}: {e}")) +} + +fn read_price_file(path: &str) -> Result>, String> { + let buf = + std::fs::read(path).map_err(|e| format!("read price file {path}: {e}"))?; + let take_u64 = |pos: usize| -> Result { + buf + .get(pos..pos + 8) + .and_then(|b| b.try_into().ok()) + .map(u64::from_le_bytes) + .ok_or_else(|| format!("price file {path}: truncated")) + }; + let count = usize::try_from(take_u64(0)?) + .map_err(|_e| "price file: count overflow".to_string())?; + let mut pos = 8; + let mut shards = Vec::with_capacity(count); + for _ in 0..count { + let len = usize::try_from(take_u64(pos)?) + .map_err(|_e| "price file: len overflow".to_string())?; + pos += 8; + let mut members = Vec::with_capacity(len); + for _ in 0..len { + let v = buf + .get(pos..pos + 4) + .and_then(|b| b.try_into().ok()) + .map(u32::from_le_bytes) + .ok_or_else(|| format!("price file {path}: truncated member"))?; + members.push(v); + pos += 4; + } + shards.push(members); + } + Ok(shards) +} + fn hex_encode(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } @@ -652,12 +873,15 @@ struct ProcPool<'a> { pieces: usize, exec_only: bool, cap_bytes: u64, - /// The whole pool as a cap — the BIG lane for retrying blocks that - /// outgrow a slot's even share. Serialized by `big_lane`: at most one - /// big worker exists, so `Σ slot caps + pool_cap` bounds worst-case - /// fleet RAM only transiently and by design. - pool_cap_bytes: u64, - big_lane: Mutex<()>, + /// Per-worker cap of the deferred-block cleanup round (the drained + /// pool split [`CLEANUP_WORKERS`] ways): after the fleet finishes, + /// blocks that could not run under a slot cap re-run through the same + /// pool code under these fat caps; survivors are named + /// resource-infeasible. + cleanup_cap_bytes: u64, + /// True in the cleanup round itself — a block failing there is named + /// infeasible instead of deferred again. + cleanup: bool, /// The parent-derived schedule serialized for children (deleted when /// the pool drops) — spawn startup is env-mmap + system build, not a /// re-derivation. @@ -668,6 +892,15 @@ struct ProcPool<'a> { order: &'a [u32], blocks: &'a [SchedBlock], fail_fast: bool, + /// Name deferred ranges resource-infeasible instead of walking them + /// in the cleanup round (`ix shard --defer-infeasible`). + defer_infeasible: bool, + /// Execute-only phase 1: children measure growth and hand dense + /// remainders back (`DEFER`) for the fat phase. + defer_growth: bool, + /// Shard member lists for the re-price round (`PRICE` verb); exported + /// to children via `IX_SCAN_PRICE_FILE`. + price_file: Option, } struct WorkerHandle { @@ -681,6 +914,9 @@ struct ScanReply { segs: Vec, skips: Vec<(Address, String)>, next: usize, + /// The worker stopped at `next` because measured growth crossed the + /// phase-1 threshold — the remainder belongs to the fat phase. + deferred: bool, } impl Drop for ProcPool<'_> { @@ -690,16 +926,22 @@ impl Drop for ProcPool<'_> { } impl ProcPool<'_> { + /// Spawn with one retry: a fresh worker that dies before its READY + /// handshake is a transient environment hiccup (systemd/D-Bus under + /// respawn churn measured one EOF in ~100 respawns), not a scan + /// failure — but an unhandled one aborts the whole scan. One backoff + /// retry covers it; a second failure is real and propagates. fn spawn(&self, slot: usize) -> Result { - self.spawn_capped(slot, self.cap_bytes) + self.spawn_once(slot).or_else(|e| { + eprintln!("[scan] worker {slot} spawn failed ({e}); retrying once"); + std::thread::sleep(std::time::Duration::from_secs(2)); + self.spawn_once(slot) + }) } - fn spawn_capped( - &self, - slot: usize, - cap_bytes: u64, - ) -> Result { + fn spawn_once(&self, slot: usize) -> Result { use std::process::{Command, Stdio}; + let cap_bytes = self.cap_bytes; let mut cmd = if self.capped { let mut c = Command::new("systemd-run"); c.args([ @@ -719,7 +961,16 @@ impl ProcPool<'_> { }; cmd .arg("shard-worker") - .env("IX_SCAN_ORDER_FILE", &self.order_file) + .env("IX_SCAN_ORDER_FILE", &self.order_file); + if let Some(pf) = &self.price_file { + cmd.env("IX_SCAN_PRICE_FILE", pf); + } + cmd + // Return freed pages to the OS immediately: the record drops at + // every segment cut, but mimalloc retains the pages by default, so + // worker RSS ratchets to its per-segment peak and the fleet sits + // at Σ caps regardless of live bytes. + .env("MIMALLOC_PURGE_DELAY", "0") .args(["--ixe", &self.ixe]) .args(["--cut-gib", &format!("{}", self.cut_used_gib)]) .args(["--batch", &format!("{}", self.batch_blocks)]) @@ -730,6 +981,9 @@ impl ProcPool<'_> { if self.exec_only { cmd.arg("--exec-only"); } + if self.defer_growth { + cmd.arg("--defer-growth"); + } let mut child = cmd .spawn() .map_err(|e| format!("spawn worker {slot} ({}): {e}", self.bin))?; @@ -762,7 +1016,12 @@ impl ProcPool<'_> { hi: usize, ) -> Result { use std::io::Write; - let mut reply = ScanReply { segs: Vec::new(), skips: Vec::new(), next: lo }; + let mut reply = ScanReply { + segs: Vec::new(), + skips: Vec::new(), + next: lo, + deferred: false, + }; if writeln!(h.stdin, "SCAN {lo} {hi}").is_err() || h.stdin.flush().is_err() { return Err(reply); @@ -807,12 +1066,59 @@ impl ProcPool<'_> { reply.next = next; return Ok(reply); }, + Some("DEFER") => { + let Some(next) = it.next().and_then(|v| v.parse::().ok()) + else { + return Err(reply); + }; + reply.next = next; + reply.deferred = true; + return Ok(reply); + }, _ => return Err(reply), } } } } +impl ProcPool<'_> { + /// One `PRICE` round-trip: the child executes shard `k`'s whole + /// CheckEnv claim cold and reports `(fft, ram_gib)` from the record — + /// the exact cost its prove pays. `Err` = the child died (over-cap + /// shard) or reported a pricing error. + fn price( + &self, + h: &mut WorkerHandle, + k: usize, + ) -> Result<(f64, f64), String> { + use std::io::Write; + writeln!(h.stdin, "PRICE {k}").map_err(|e| e.to_string())?; + h.stdin.flush().map_err(|e| e.to_string())?; + let line = h.read_line()?; + let mut it = line.split_whitespace(); + match it.next() { + Some("COST") => { + let (Some(fft), Some(ram)) = ( + it.next().and_then(|v| v.parse::().ok()), + it.next().and_then(|v| v.parse::().ok()), + ) else { + return Err(format!("bad COST reply {line:?}")); + }; + Ok((fft, ram)) + }, + Some("PERR") => Err( + it.next() + .and_then(hex_decode) + .map_or_else( + || "pricing error".to_string(), + |m| String::from_utf8_lossy(&m).into_owned(), + ), + ), + _ => Err(format!("bad PRICE reply {line:?}")), + } + } +} + impl WorkerHandle { fn read_line(&mut self) -> Result { use std::io::BufRead; @@ -840,10 +1146,13 @@ impl WorkerHandle { /// content every worker periodically fills its cap and is OOM-killed — /// death IS the cache-shedding mechanism, and it is cheap: segments /// stream as they close, so a kill loses only the work since the last -/// closed segment. The parent respawns and continues from the committed -/// index; the fresh cache carries it until the next shed. A block that -/// yields zero progress twice in a row cannot even START under the slot -/// cap — that one block is measured on the BIG lane (whole-pool cap) or +/// closed segment. The parent respawns and resumes from the committed +/// index with a narrow prefix (the resumed range's first blocks execute +/// one per claim), so a dense stretch banks per-block progress instead +/// of re-dying at full claim width. A block whose own single claim dies +/// under the slot cap is DEFERRED: after the fleet drains, the deferred +/// blocks re-run through this same function under fat caps (the freed +/// pool split [`CLEANUP_WORKERS`] ways); a block that dies even there is /// named resource-infeasible. The fleet's RAM bound is `Σ caps`, /// enforced by the kernel, independent of content. fn run_pool_procs( @@ -852,10 +1161,8 @@ fn run_pool_procs( workers: usize, failed: &Mutex>, ) -> Result, String> { - // (origin chunk, commit sequence, lo, hi, stalls): `stalls` counts - // consecutive deaths at `lo` with zero committed progress — two in a - // row means the block at `lo` cannot even start under the slot cap. - type Range = (u32, u32, usize, usize, u8); + // (origin chunk, commit sequence, lo, hi). + type Range = (u32, u32, usize, usize); let total_blocks: usize = chunks.iter().map(|(lo, hi)| hi - lo).sum(); let start = std::time::Instant::now(); let queue: Mutex> = Mutex::new( @@ -863,7 +1170,7 @@ fn run_pool_procs( .into_iter() .enumerate() .map(|(i, (lo, hi))| { - (u32::try_from(i).expect("chunk count fits u32"), 0u32, lo, hi, 0u8) + (u32::try_from(i).expect("chunk count fits u32"), 0u32, lo, hi) }) .collect(), ); @@ -873,12 +1180,30 @@ fn run_pool_procs( let done: Mutex)>> = Mutex::new(Vec::new()); let failure: Mutex> = Mutex::new(None); let abort = std::sync::atomic::AtomicBool::new(false); + // (origin, lo, hi) ranges whose opening claim died on a fresh worker — + // walked cumulatively in the cleanup round after the fleet drains. + // Deep dense strips are only cheap CUMULATIVELY (a walk shares the + // strip's dependency cone in one record; any solo measurement pays the + // whole cone per block), so a range whose resume point cannot even + // open under a slot moves to the fat round wholesale instead of the + // fleet paying one doomed cone-derivation per block. + let deferred: Mutex> = Mutex::new(Vec::new()); std::thread::scope(|s| { let (queue, in_flight, done, failure, abort) = (&queue, &in_flight, &done, &failure, &abort); - let (blocks_done, last_pct) = (&blocks_done, &last_pct); + let (blocks_done, last_pct, deferred) = (&blocks_done, &last_pct, &deferred); for slot in 0..workers { s.spawn(move || { + // Ranges served by the current child; at [`WORKER_RECYCLE_RANGES`] + // the parent reaps and respawns it proactively. + let mut served = 0usize; + // True until the current child completes its first scan: only a + // FRESH child's zero-progress death convicts a block — an aged + // child dying on a range's first claim indicts its own decode + // cache, not the block (348 false deferrals measured before this + // distinction; the requeued range simply waits for a fresh + // owner). + let mut fresh = true; let mut worker = match pool.spawn(slot) { Ok(w) => w, Err(e) => { @@ -929,9 +1254,16 @@ fn run_pool_procs( } Ok(reply.next) }; - let requeue = |origin: u32, seq: u32, lo: usize, hi: usize, stalls| { + // Remainders go to the queue FRONT: a healthy remainder is + // usually re-popped by the worker that just banked its segments + // (cache still warm with the region's cone), and a death's + // remainder retries while its neighborhood is warm — pushed to + // the back, dense-region remainders sank behind hundreds of + // chunks and resurfaced 20 minutes later on cold workers, which + // died again and deferred the region wholesale. + let requeue = |origin: u32, seq: u32, lo: usize, hi: usize| { if lo < hi { - queue.lock().unwrap().push_back((origin, seq, lo, hi, stalls)); + queue.lock().unwrap().push_front((origin, seq, lo, hi)); } }; loop { @@ -946,23 +1278,62 @@ fn run_pool_procs( } popped }; - let Some((origin, seq, lo, hi, stalls)) = next else { + let Some((origin, seq, lo, hi)) = next else { if in_flight.load(Ordering::Acquire) == 0 { break; } std::thread::sleep(std::time::Duration::from_millis(50)); continue; }; + // Proactive recycle between ranges: the env decode cache grows + // monotonically and never shrinks, so a long-lived child ages + // toward its cap until ANY dense block kills it — a full-scan + // fleet reaching the dense tail with saturated caches misread + // the whole zone as monsters (161 false deferrals; the same + // tail scanned by young workers ran in 2 minutes with zero). + // A fresh child costs seconds (order file + env mmap). + served += 1; + if served > WORKER_RECYCLE_RANGES { + served = 1; + match pool.spawn(slot) { + Ok(w) => { + std::mem::replace(&mut worker, w).reap(); + fresh = true; + }, + Err(err) => { + let mut f = failure.lock().unwrap(); + if f.is_none() { + *f = Some(err); + } + abort.store(true, Ordering::Release); + break; + }, + } + } match pool.scan(&mut worker, lo, hi) { Ok(reply) => { + fresh = false; + let was_deferred = reply.deferred; let Ok(next) = commit(reply, origin, seq) else { abort.store(true, Ordering::Release); break; }; - progress(next.saturating_sub(lo)); - requeue(origin, seq + 1, next, hi, 0); + if was_deferred && next < hi { + // Growth-threshold handoff: the walked prefix is banked; + // the dense remainder waits for the fat phase. + eprintln!( + "[scan] range {next}..{hi} defers to the fat phase \ + (growth threshold)" + ); + deferred.lock().unwrap().push((origin, next, hi)); + progress(hi.saturating_sub(lo)); + } else { + progress(next.saturating_sub(lo)); + requeue(origin, seq + 1, next, hi); + } }, Err(partial) => { + let was_fresh = fresh; let e = match commit(partial, origin, seq) { Ok(n) => n, Err(()) => { @@ -986,75 +1357,60 @@ fn run_pool_procs( }, ) .reap(); + fresh = true; if e >= hi { eprintln!( "[scan] worker {slot} died ({status}) after completing \ its range; respawned" ); - } else if e > lo || stalls < 1 { - // A cache-shed kill: the fresh worker continues from the - // committed index. `e == lo` earns one fresh-worker - // attempt before block `e` is treated as unstartable. - let stalls = if e > lo { 0 } else { stalls + 1 }; + } else if e > lo || !was_fresh { + // A cache-shed kill: the respawned child (fresh record + // and decode cache) continues from the committed index. + // An AGED child dying on a range's first claim indicts + // its cache, not the block — the range requeues intact + // and waits for a fresh owner to judge it. eprintln!( "[scan] worker {slot} died ({status}) at index {e}; \ respawned, continuing" ); - requeue(origin, seq + 1, e, hi, stalls); + requeue(origin, seq + 1, e, hi); } else { - // Two consecutive zero-progress deaths: block `e` cannot - // even start under the slot cap. BIG-lane retry: one - // worker at a time gets the whole pool as its cap, so a - // block that is heavy-but-provable measures instead of - // being falsely excluded by its slot's even share. + // A fresh worker died on the range's opening claim: this + // resume point cannot even open under a slot. In the + // fleet, the WHOLE remainder defers to the cleanup round, + // which walks it cumulatively under a fat cap — deferring + // only the block would re-pay the strip's cone per block, + // one doomed execution each (measured: 1,086 deferrals). + // In the cleanup round itself the block is named + // resource-infeasible and the walk continues past it. let addr = pool.blocks[pool.order[e] as usize].addr.clone(); - let big_reply = { - let _lane = pool.big_lane.lock().unwrap(); - pool.spawn_capped(slot, pool.pool_cap_bytes).ok().map( - |mut big| { - let r = pool.scan(&mut big, e, e + 1); - big.reap(); - r - }, - ) - }; - match big_reply { - Some(Ok(reply)) => { - if commit(reply, origin, seq).is_err() { - abort.store(true, Ordering::Release); - break; - } - eprintln!( - "[scan] block {} exceeded its slot cap ({status}) \ - but measured on the big lane", - addr.hex() - ); - }, - other => { - if let Some(Err(partial2)) = other { - let _ = commit(partial2, origin, seq); - } - eprintln!( - "[scan] block {} exceeded the worker memory cap \ - ({status}) and the big lane — resource-infeasible; \ - skipped", - addr.hex() - ); - failed.lock().unwrap().push(( - addr, - format!( - "record outgrew the {:.1} GiB whole-pool cap \ - mid-claim (cgroup OOM-kill)", - f64_from_usize( - usize::try_from(pool.pool_cap_bytes) - .unwrap_or(usize::MAX) - ) / GIB - ), - )); - }, + if pool.cleanup { + eprintln!( + "[scan] block {} exceeded the cleanup cap ({status}) \ + — resource-infeasible; skipped", + addr.hex() + ); + failed.lock().unwrap().push(( + addr, + format!( + "record outgrew the {:.1} GiB cleanup cap mid-claim \ + (cgroup OOM-kill)", + f64_from_usize( + usize::try_from(pool.cap_bytes).unwrap_or(usize::MAX) + ) / GIB + ), + )); + progress(1); + requeue(origin, seq + 1, e + 1, hi); + } else { + eprintln!( + "[scan] range {e}..{hi} cannot open under its slot \ + cap ({status}); deferred to the cleanup round" + ); + let _ = addr; + deferred.lock().unwrap().push((origin, e, hi)); + progress(hi - e); } - progress(1); - requeue(origin, seq + 1, e + 1, hi, 0); } }, } @@ -1073,6 +1429,109 @@ fn run_pool_procs( for (_, mut segs) in tagged { segments.append(&mut segs); } + let mut deferred = deferred.into_inner().unwrap(); + // Defer-infeasible mode: name every deferred block + // resource-infeasible instead of walking the deferred ranges under + // fat caps. The deferred region's cost is cone-bound kernel + // execution (measured ~6-10 worker-hours on FLT's typeclass-instance + // core in every slot configuration), so a caller can choose a + // partition of the tractable content NOW plus an exact exclusion + // inventory, over an hours-long exhaustive walk. + if !deferred.is_empty() && pool.defer_infeasible { + deferred.sort_unstable(); + deferred.dedup(); + let mut f = failed.lock().unwrap(); + let mut named = 0usize; + for &(_, lo, hi) in &deferred { + for &b in &pool.order[lo..hi] { + f.push(( + pool.blocks[b as usize].addr.clone(), + "deferred dense-core block (IX_SCAN_DEFER_INFEASIBLE=1): \ + opening cone exceeds a fleet slot; not measured" + .to_string(), + )); + named += 1; + } + } + eprintln!( + "[scan] defer-infeasible: {named} deferred block(s) in \ + {} range(s) named infeasible without measurement", + deferred.len() + ); + return Ok(segments); + } + if !deferred.is_empty() { + // Cleanup round: the deferred ranges re-run through this same + // function under fat caps — the drained pool split a few ways — so + // dense strips WALK (cone shared, segments cut gracefully at the + // fat soft cut) instead of being excluded by a slot's even share. + // Sorted for a deterministic round; `cleanup: true` names blocks + // that still cannot open resource-infeasible. + deferred.sort_unstable(); + deferred.dedup(); + // The fat phase's soft cut is cap-derived: dense-region cones run + // 12-16+ GiB, so segments must exceed the cone to amortize it — a + // small quantum re-pays the cone per segment (measured: no faster + // and many more false infeasibles). + let cleanup_soft_gib = (f64_from_usize( + usize::try_from(pool.cleanup_cap_bytes).unwrap_or(usize::MAX), + ) / GIB + - WORKER_BASELINE_GIB + - CLAIM_HEADROOM_GIB) + .max(1.0); + let cleanup_pool = ProcPool { + bin: pool.bin.clone(), + ixe: pool.ixe.clone(), + cut_used_gib: pool.cut_used_gib, + batch_blocks: pool.batch_blocks, + soft_record_gib: cleanup_soft_gib, + pieces: pool.pieces, + exec_only: pool.exec_only, + cap_bytes: pool.cleanup_cap_bytes, + cleanup_cap_bytes: pool.cleanup_cap_bytes, + cleanup: true, + order_file: pool.order_file.clone(), + capped: pool.capped, + order: pool.order, + blocks: pool.blocks, + fail_fast: pool.fail_fast, + defer_infeasible: false, + defer_growth: false, + price_file: None, + }; + // Coalesce adjacent deferred ranges: strip remainders abut when a + // strip spans chunk edges, and a merged range shares its dependency + // cone across the walk. + let mut ranges: Vec<(usize, usize)> = Vec::new(); + for &(_, lo, hi) in &deferred { + match ranges.last_mut() { + Some((_, top)) if *top >= lo => *top = (*top).max(hi), + _ => ranges.push((lo, hi)), + } + } + let total: usize = ranges.iter().map(|(lo, hi)| hi - lo).sum(); + eprintln!( + "[scan] cleanup round: {total} deferred block(s) in {} range(s), {} \ + workers × {:.1} GiB", + ranges.len(), + CLEANUP_WORKERS.min(ranges.len()), + f64_from_usize( + usize::try_from(pool.cleanup_cap_bytes).unwrap_or(usize::MAX) + ) / GIB + ); + let extra = run_pool_procs( + &cleanup_pool, + ranges, + CLEANUP_WORKERS.min(deferred.len()), + failed, + )?; + segments.extend(extra); + // Deferred singles landed out of order; restore schedule adjacency + // so the merge pass sums true neighbors. + let pos: std::collections::HashMap = + pool.order.iter().enumerate().map(|(i, &b)| (b, i)).collect(); + segments.sort_by_key(|s| pos.get(&s.blocks[0]).copied().unwrap_or(0)); + } Ok(segments) } @@ -1124,11 +1583,22 @@ pub fn execute_env( // Post-schedule RSS: the parent's decode cache and static structures — // the residency the worker fleet's record budget sits on top of. let baseline_gib = process_rss_gib(); - let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - // Fleet bound by construction: Σ worker slices + big lane + parent + - // OS reserve = box RAM. Width goes to the core count when the pool - // affords a floor slice per worker. - let pool_gib = (ram - baseline_gib - OS_RESERVE_GIB - BIG_LANE_GIB) + // `IX_SCAN_RAM_GIB` overrides detected box RAM: every derived number + // (pool, width, caps, fat-phase slots) then scales exactly as a box + // of that size would — a budget emulation knob for capacity tests. + let ram = std::env::var("IX_SCAN_RAM_GIB") + .ok() + .and_then(|v| v.parse::().ok()) + .unwrap_or_else(|| crate::kernel::system_ram_gib().unwrap_or(64.0)); + // Fleet bound by construction: Σ worker slices + parent + OS reserve + + // the env's page-cache residency (×2 re-read slack) = box RAM. Width + // goes to the core count when the pool affords a floor slice per + // worker. + let env_cache_gib = 2.0 * f64_from_usize( + usize::try_from(env_bytes).unwrap_or(usize::MAX), + ) / GIB; + let pool_gib = ((ram - baseline_gib - OS_RESERVE_GIB - env_cache_gib) + * POOL_SLICE_FRAC) .max(SLICE_FLOOR_GIB); let workers = bound_workers_by_pool(workers, pool_gib, proc_workers.is_some()); @@ -1141,12 +1611,13 @@ pub fn execute_env( let n_chunks = (blocks.len() / CHUNK_TARGET_BLOCKS) .max(workers * 2) .min(blocks.len()); + let bounds = make_chunk_bounds(&order, &blocks, env_bytes, n_chunks); eprintln!( - "[exec] {} blocks, {workers} workers over {n_chunks} chunks, record \ + "[exec] {} blocks, {workers} workers over {} chunks, record \ drop at {record_cut_gib:.1} GiB, {batch_blocks} blocks per claim", - blocks.len() + blocks.len(), + bounds.len() ); - let bounds = make_chunk_bounds(&order, &blocks, env_bytes, n_chunks); let failed: Mutex> = Mutex::new(Vec::new()); let abort = std::sync::atomic::AtomicBool::new(false); let ctx = ScanCtx { @@ -1161,6 +1632,7 @@ pub fn execute_env( abort: &abort, batch_blocks, system: None, + defer_growth: Some(DEFER_GROWTH_BYTES_PER_BLOCK), soft_record_gib: f64::INFINITY, }; let segments = match proc_workers { @@ -1191,15 +1663,18 @@ pub fn execute_env( pieces: sched_pieces, exec_only: true, cap_bytes: gib_to_bytes_u64(cap_gib), - // The BIG lane's budget is reserved out of the pool up front, so - // a big measurement plus a full fleet never overcommits the box. - pool_cap_bytes: gib_to_bytes_u64(BIG_LANE_GIB), - big_lane: Mutex::new(()), + cleanup_cap_bytes: gib_to_bytes_u64( + pool_gib / f64_from_usize(CLEANUP_WORKERS), + ), + cleanup: false, order_file, capped, order: &order, blocks: &blocks, fail_fast, + defer_infeasible: false, + defer_growth: true, + price_file: None, }; run_pool_procs(&pool, bounds, workers, &failed)? }, @@ -1254,6 +1729,8 @@ pub fn scan_shards( eps: f64, workers: usize, fail_fast: bool, + defer_infeasible: bool, + reprice: bool, out_path: &str, proc_workers: Option<(&str, &str)>, ) -> Result { @@ -1299,17 +1776,29 @@ pub fn scan_shards( // Post-schedule RSS: the parent's decode cache and static structures — // the residency the worker pool's budget sits on top of. let baseline_gib = process_rss_gib(); - // Width-first sizing, uniform for every env and budget: full-core - // width, each worker's cap its even slice of the pool, and the record - // threshold (exact heap bytes) set so baseline + one claim's growth - // still fits under the cap — the kernel kill is a backstop, not the - // routine mechanism. The prove budget only sets the CUT and the merge - // target; scan wall never depends on it. Blocks too heavy for a slice - // escalate to the reserved big lane (serialized) or are named. - let ram = crate::kernel::system_ram_gib().unwrap_or(64.0); - // Fleet bound by construction: Σ worker slices + big lane + parent + - // OS reserve = box RAM. - let pool_gib = (ram - baseline_gib - OS_RESERVE_GIB - BIG_LANE_GIB) + // Width-first sizing: full core width while every worker's even slice + // of the pool clears the floor. Claim widths derived from measured + // growth bound mid-claim overshoot on any content, so slices are + // segment quanta, not worst-case-claim reserves — the merge pass sums + // segments to the cut, and the kernel kill stays a backstop. Blocks + // too heavy even for a slice are deferred to the fat-cap cleanup + // round or named infeasible. + // `IX_SCAN_RAM_GIB` overrides detected box RAM: every derived number + // (pool, width, caps, fat-phase slots) then scales exactly as a box + // of that size would — a budget emulation knob for capacity tests. + let ram = std::env::var("IX_SCAN_RAM_GIB") + .ok() + .and_then(|v| v.parse::().ok()) + .unwrap_or_else(|| crate::kernel::system_ram_gib().unwrap_or(64.0)); + // Fleet bound by construction: Σ worker slices + parent + OS reserve + + // the env's page-cache residency = box RAM. The env term keeps the + // shared mmap cache-resident (×2 for re-read slack): without it, a + // fleet at its caps evicts the very pages every worker faults from. + let env_cache_gib = 2.0 * f64_from_usize( + usize::try_from(env_bytes).unwrap_or(usize::MAX), + ) / GIB; + let pool_gib = ((ram - baseline_gib - OS_RESERVE_GIB - env_cache_gib) + * POOL_SLICE_FRAC) .max(SLICE_FLOOR_GIB); let workers = bound_workers_by_pool(workers, pool_gib, proc_workers.is_some()); @@ -1322,15 +1811,15 @@ pub fn scan_shards( let n_chunks = (blocks.len() / CHUNK_TARGET_BLOCKS) .max(workers * 2) .min(blocks.len()); + let bounds = make_chunk_bounds(&order, &blocks, env_bytes, n_chunks); + let chunk_count = bounds.len(); eprintln!( - "[scan] {} blocks, {workers} workers over {n_chunks} chunks, cut at \ + "[scan] {} blocks, {workers} workers over {chunk_count} chunks, cut at \ {cut_used_gib:.1} GiB predicted prove RSS (margin \ {:.0}%, ε pre-charged), {batch_blocks} blocks per claim", blocks.len(), (1.0 - PROVE_RAM_MARGIN) * 100.0 ); - let bounds = make_chunk_bounds(&order, &blocks, env_bytes, n_chunks); - let chunk_count = bounds.len(); let failed: Mutex> = Mutex::new(Vec::new()); let abort = std::sync::atomic::AtomicBool::new(false); let ctx = ScanCtx { @@ -1345,6 +1834,7 @@ pub fn scan_shards( abort: &abort, batch_blocks, system: Some(system), + defer_growth: None, soft_record_gib: f64::INFINITY, }; let segments = match proc_workers { @@ -1376,15 +1866,18 @@ pub fn scan_shards( pieces: sched_pieces, exec_only: false, cap_bytes: gib_to_bytes_u64(cap_gib), - // The BIG lane's budget is reserved out of the pool up front, so - // a big measurement plus a full fleet never overcommits the box. - pool_cap_bytes: gib_to_bytes_u64(BIG_LANE_GIB), - big_lane: Mutex::new(()), + cleanup_cap_bytes: gib_to_bytes_u64( + pool_gib / f64_from_usize(CLEANUP_WORKERS), + ), + cleanup: false, order_file, capped, order: &order, blocks: &blocks, fail_fast, + defer_infeasible, + defer_growth: false, + price_file: None, }; run_pool_procs(&pool, bounds, workers, &failed)? }, @@ -1395,36 +1888,209 @@ pub fn scan_shards( }, }; - // Assemble shards by summing adjacent segments up to the cut, to a - // fixpoint. Sums are conservative for every cost in play: shared - // dependencies derive once in the union, and padded heights are - // subadditive — so a summed shard can only OVER-state its prove RSS, - // never breach the budget. The conservatism (measured ~5-15% extra - // shards vs a re-measured pack) is the price of planning wall time - // never depending on the prove budget: segments are scanned at - // RAM-optimal size and packing is pure arithmetic. + // Assemble shards by summing adjacent segments, then COLD RE-PRICE + // each merged shard: one execution of its whole CheckEnv claim (the + // exact claim its prove runs) replaces the summed cost. Sums are + // conservative (shared cones derive once in the union; padded heights + // are subadditive) but by a measured ~1.6x, so the merge packs past + // the cut by [`PACK_OVERSHOOT`] and the re-price decides: an over-cut + // shard splits at its ram midpoint and the halves re-price, to a + // bounded depth. Process-pool mode only; the thread pool (tests) + // keeps the pure summed pack at the plain cut. let pre_merge = segments.len(); - let mut list = segments; - loop { - let mut merged: Vec = Vec::new(); - let mut any = false; - for seg in list { - match merged.last_mut() { - Some(prev) if prev.ram_gib + seg.ram_gib < cut_used_gib => { - prev.blocks.extend(seg.blocks); - prev.fft += seg.fft; - prev.ram_gib += seg.ram_gib; - any = true; + // Opt-in (`ix shard --reprice`, fail-fast mode strings "3"/"4"): the + // cold re-price is prove-validated on Init (+0.77% at a shard packed + // to the cut) but not yet on FLT/Mathlib-class content, so summed + // conservative costs remain the default until each env's re-priced + // manifest passes its heaviest-shard prove protocol. + let pricing = reprice && proc_workers.is_some(); + let pack_target = + if pricing { cut_used_gib * PACK_OVERSHOOT } else { cut_used_gib }; + let mut groups: Vec> = Vec::new(); + { + let mut sums: Vec = Vec::new(); + for seg in segments { + match (groups.last_mut(), sums.last_mut()) { + (Some(g), Some(sum)) if *sum + seg.ram_gib < pack_target => { + *sum += seg.ram_gib; + g.push(seg); + }, + _ => { + sums.push(seg.ram_gib); + groups.push(vec![seg]); }, - _ => merged.push(seg), } } - list = merged; - if !any { - break; + } + // (summed fft, summed ram, priced (fft, ram) once measured) + let group_sum = |g: &Vec| -> (f64, f64) { + g.iter().fold((0.0, 0.0), |(f, r), s| (f + s.fft, r + s.ram_gib)) + }; + let mut priced: Vec> = vec![None; groups.len()]; + if pricing { + let (bin, ixe) = proc_workers.expect("pricing implies proc workers"); + let t0 = std::time::Instant::now(); + // The scan pool (and its order file) are gone; the price pool gets + // fresh copies of both sidecar files. + let order_file = std::env::temp_dir() + .join(format!("ix-price-order-{}.bin", std::process::id())); + write_order_file(&order_file, &blocks, &order)?; + let price_file = std::env::temp_dir() + .join(format!("ix-price-shards-{}.bin", std::process::id())); + let width = REPRICE_WORKERS.min(groups.len()).max(1); + let cap_gib = (pool_gib / f64_from_usize(REPRICE_WORKERS)) + .max(SLICE_FLOOR_GIB); + let price_pool = ProcPool { + bin: bin.to_string(), + ixe: ixe.to_string(), + cut_used_gib, + batch_blocks, + soft_record_gib: f64::INFINITY, + pieces: sched_pieces, + exec_only: false, + cap_bytes: gib_to_bytes_u64(cap_gib), + cleanup_cap_bytes: gib_to_bytes_u64(cap_gib), + cleanup: true, + order_file: order_file.clone(), + capped: systemd_scope_caps_available(), + order: &order, + blocks: &blocks, + fail_fast: false, + defer_infeasible: false, + defer_growth: false, + price_file: Some(price_file.clone()), + }; + // Rounds: price every unpriced group; split over-cut multi-segment + // groups at their summed-ram midpoint and unprice the halves. + for _round in 0..3 { + let todo: Vec = + (0..groups.len()).filter(|&i| priced[i].is_none()).collect(); + if todo.is_empty() { + break; + } + let members: Vec> = todo + .iter() + .map(|&i| { + groups[i].iter().flat_map(|s| s.blocks.iter().copied()).collect() + }) + .collect(); + write_price_file(&price_file, &members)?; + let queue: Mutex> = + Mutex::new((0..todo.len()).collect()); + let results: Mutex>> = + Mutex::new(vec![None; todo.len()]); + std::thread::scope(|sc| { + for slot in 0..width.min(todo.len()) { + let (queue, results, price_pool) = (&queue, &results, &price_pool); + sc.spawn(move || { + let mut worker = match price_pool.spawn(slot) { + Ok(w) => w, + Err(_e) => return, + }; + loop { + let Some(j) = queue.lock().unwrap().pop_front() else { + break; + }; + match price_pool.price(&mut worker, j) { + Ok(cost) => results.lock().unwrap()[j] = Some(cost), + Err(_e) => { + // Death or pricing error: one fresh-worker retry, + // then the group falls back to its summed cost. + worker = match price_pool.spawn(slot) { + Ok(w) => w, + Err(_e) => break, + }; + if let Ok(cost) = price_pool.price(&mut worker, j) { + results.lock().unwrap()[j] = Some(cost); + } + } + } + } + worker.reap(); + }); + } + }); + let results = results.into_inner().unwrap(); + for (pos, &i) in todo.iter().enumerate() { + priced[i] = Some(match results[pos] { + Some(cost) => cost, + None => group_sum(&groups[i]), + }); + } + // Split over-cut multi-segment groups; their halves re-price in + // the next round. + let mut next_groups: Vec> = Vec::new(); + let mut next_priced: Vec> = Vec::new(); + let mut split = 0usize; + for (i, g) in groups.into_iter().enumerate() { + let over = priced[i].is_some_and(|(_f, r)| r >= cut_used_gib); + if over && g.len() > 1 { + let total: f64 = g.iter().map(|s| s.ram_gib).sum(); + let mut acc = 0.0; + let mut cutp = g.len() - 1; + for (k, s) in g.iter().enumerate() { + acc += s.ram_gib; + if acc >= total / 2.0 { + cutp = (k + 1).min(g.len() - 1); + break; + } + } + let mut a = g; + let b = a.split_off(cutp); + split += 1; + next_groups.push(a); + next_priced.push(None); + next_groups.push(b); + next_priced.push(None); + } else { + next_priced.push(priced[i]); + next_groups.push(g); + } + } + groups = next_groups; + priced = next_priced; + if split == 0 { + break; + } + eprintln!("[scan] re-price: {split} over-cut shard(s) split"); } + let _ = std::fs::remove_file(&order_file); + let _ = std::fs::remove_file(&price_file); + let ratios: Vec = groups + .iter() + .zip(&priced) + .filter_map(|(g, p)| { + p.map(|(_f, r)| { + let (_sf, sr) = group_sum(g); + if sr > 0.0 { r / sr } else { 1.0 } + }) + }) + .collect(); + let (rmin, rmax) = ratios.iter().fold((f64::MAX, 0.0f64), |(lo, hi), &r| { + (lo.min(r), hi.max(r)) + }); + eprintln!( + "[scan] re-price: {} shard(s) cold-priced in {:.0}s \ + (true/summed {:.2}-{:.2})", + groups.len(), + t0.elapsed().as_secs_f64(), + rmin, + rmax + ); } - let segments = list; + // Flatten to the manifest's segment shape, carrying the priced (or + // summed-fallback) cost per shard. + let segments: Vec = groups + .into_iter() + .zip(priced) + .map(|(g, p)| { + let (sf, sr) = group_sum(&g); + let (fft, ram_gib) = p.unwrap_or((sf, sr)); + let blocks: Vec = + g.into_iter().flat_map(|s| s.blocks).collect(); + Segment { blocks, fft, ram_gib } + }) + .collect(); // Manifest: owned blocks per segment; frontier fields are the claim // layer's business (reconstructed from env + owned at check/prove time). @@ -1555,17 +2221,25 @@ fn scan_range( ctx: &ScanCtx<'_>, chunk: &[u32], origin: u32, -) -> Result<(Vec, Vec), String> { +) -> Result<(Vec, Vec, bool), String> { let t0 = std::time::Instant::now(); let chunk_id = origin; let n_chunks = ctx.n_chunks; let mut segments: Vec = Vec::new(); let mut lo = 0usize; + // Set when measured growth crossed the phase-1 threshold: the range's + // remainder is handed back marked for the fat phase. + let mut defer_rest = false; // Blocks below this index (and at/after `lo`) execute one per claim: // a batch-level event landed in [lo, narrow_until) and needs per-block // attribution. Stale values (< hi) are inert. let mut narrow_until = 0usize; - while lo < chunk.len() && segments.len() < RANGE_SEGMENTS { + // Running record growth per block (bytes), from the last claim's + // measured growth — the range's execution history is content-fixed, + // so the estimate (and thus every claim width) is deterministic. + // `None` until the first claim measures. + let mut growth_per_block: Option = None; + while lo < chunk.len() && segments.len() < RANGE_SEGMENTS && !defer_rest { let mut record = QueryRecord::new(ctx.toplevel); let mut io = IOBuffer::with_backing(EnvFaultSource::new(ctx.env.clone())); let mut prev_fft = 0.0f64; @@ -1579,15 +2253,38 @@ fn scan_range( if ctx.abort.load(Ordering::Acquire) { return Err("aborted after a failure elsewhere".to_string()); } + // Claim width from measured growth: K sized so this claim's + // expected record growth is ~CLAIM_TARGET_GIB. Light content runs + // full width; dense content shrinks to K=1-2, where per-claim + // overhead is negligible against per-block cost — one rule bounds + // mid-claim growth on every content class. Before the first + // measurement the estimate is unknown and the claim starts small. let k = if hi < narrow_until { 1 } else { - ctx.batch_blocks.min(chunk.len() - hi) + let by_growth = match growth_per_block { + // No measurement yet: a single block seeds the estimator. A + // wider opening claim cascades in monster strips — after a + // deferral the follow-up range also starts unmeasured, so any + // multi-block seed re-dies block after block (measured: 998 + // one-death-one-deferral blocks at a 4-block seed, where the + // same strips scanned clean once estimators were trained). + None => 1, + Some(g) => { + let target = CLAIM_TARGET_GIB * GIB; + format!("{:.0}", (target / g.max(1.0)).clamp(1.0, 4096.0)) + .parse::() + .unwrap_or(1) + .min(ctx.batch_blocks) + }, + }; + by_growth.min(chunk.len() - hi) }; let addrs: Vec
= chunk[hi..hi + k] .iter() .map(|&b| ctx.blocks[b as usize].addr.clone()) .collect(); + let heap_before = record_heap_bytes(&record); let out: Result<(), String> = seed_shard_check_env_claim( ctx.env, &addrs, &mut io, ) @@ -1602,6 +2299,33 @@ fn scan_range( .map(|_| ()) .map_err(|e| e.to_string()) }); + growth_per_block = Some( + (f64_from_usize(record_heap_bytes(&record).saturating_sub( + heap_before, + )) / f64_from_usize(k)) + .max(1.0), + ); + // Phase-1 growth deferral: the claim that just executed is banked + // (its checks are done), and the remainder waits for the fat + // phase — dense content is only cheap walked warm with room, and + // the threshold sits in the decade-wide gap between the light and + // dense growth populations. + if let (Some(threshold), Some(g)) = (ctx.defer_growth, growth_per_block) + && g > threshold + && hi >= narrow_until + { + defer_rest = true; + break (hi + k, record_fft_cost(ctx.toplevel, &record), { + let rec = + f64_from_usize(record_heap_bytes(&record)) / GIB; + match ctx.system { + Some(sys) => { + f64_from_usize(sys.peak_prove_bytes(&record).peak) / GIB + }, + None => rec, + } + }); + } if let Err(e) = out { if k > 1 { // Per-block attribution needed: end the segment at the last @@ -1661,6 +2385,16 @@ fn scan_range( } break (hi, prev_fft, prev_ram); } + if segments.is_empty() && lo == 0 && hi == lo { + // Bank the range's very first claim as its own segment: the + // committed index then advances past it immediately, so any + // later death in this range preserves progress (`e > lo`) and + // is answered by respawn-and-continue. A zero-progress death + // therefore means exactly "this claim, alone, on this worker" — + // the conviction the deferral path assumes. One extra seed-size + // segment per range; the merge pass absorbs it. + break (hi + k, fft, ram_gib); + } hi += k; prev_fft = fft; prev_ram = ram_gib; @@ -1713,7 +2447,7 @@ fn scan_range( t0.elapsed().as_secs_f64() ); } - Ok((segments, chunk[lo..].to_vec())) + Ok((segments, chunk[lo..].to_vec(), defer_rest)) } use lean_ffi::object::{ @@ -1754,7 +2488,13 @@ extern "C" fn rs_aiur_scan_shards_with_env( } let eps = eps_pct.to_string().parse::().unwrap_or(5.0) / 100.0; let workers = workers.to_string().parse::().unwrap_or(0); - let fail_fast = fail_fast.to_string() != "0"; + // `fail_fast` mode string: "1" abort on the first kernel reject, "0" + // record-and-skip, "2" record-and-skip + name deferred dense ranges + // infeasible, "3" as "0" + cold re-price, "4" as "2" + cold re-price. + let mode = fail_fast.to_string(); + let fail_fast = mode == "1"; + let defer_infeasible = mode == "2" || mode == "4"; + let reprice = mode == "3" || mode == "4"; let (bin, ixe) = (worker_bin.to_string(), ixe_path.to_string()); let proc_workers = (!bin.is_empty() && !ixe.is_empty()) .then_some((bin.as_str(), ixe.as_str())); @@ -1766,6 +2506,8 @@ extern "C" fn rs_aiur_scan_shards_with_env( eps, workers, fail_fast, + defer_infeasible, + reprice, &out_path.to_string(), proc_workers, ) { @@ -1842,7 +2584,11 @@ extern "C" fn rs_aiur_scan_worker( let batch = batch.to_string().parse::().unwrap_or(SCAN_BATCH_BLOCKS); let soft = soft_cap_gib.to_string().parse::().unwrap_or(f64::INFINITY); let pieces = pieces.to_string().parse::().unwrap_or(16); - let exec_only = exec_only.to_string() == "1"; + // Mode string: "0" scan, "1" execute-only, "2" execute-only with + // growth-threshold deferral (phase 1 of the two-phase execute). + let mode = exec_only.to_string(); + let exec_only = mode == "1" || mode == "2"; + let defer_growth = mode == "2"; match scan_worker( system.get(), fun_idx, @@ -1852,6 +2598,7 @@ extern "C" fn rs_aiur_scan_worker( soft, pieces, exec_only, + defer_growth, ) { Ok(()) => LeanExcept::ok(LeanOwned::box_usize(0)), Err(e) => LeanExcept::error_string(&format!("rs_aiur_scan_worker: {e}")), From 181dbaac8b210227c4ec6c8283201e76fb87cd68 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Fri, 7 Aug 2026 21:11:10 +0000 Subject: [PATCH 18/20] bench: whole-env aiur execute rows via envRows; drop aiur-shard backend; addr-of owning-shard lookup --- .../workflows/bencher-thresholds-reset.yml | 8 +- Ix/Cli/AddrOfCmd.lean | 41 +++- Ix/Cli/BenchCmd.lean | 183 ++++++++++-------- Ix/Cli/BenchPlots.lean | 30 ++- Ix/Cli/BenchReport.lean | 8 +- Ix/Cli/CheckCmd.lean | 41 ++-- 6 files changed, 186 insertions(+), 125 deletions(-) diff --git a/.github/workflows/bencher-thresholds-reset.yml b/.github/workflows/bencher-thresholds-reset.yml index c5a003002..b4b5947fd 100644 --- a/.github/workflows/bencher-thresholds-reset.yml +++ b/.github/workflows/bencher-thresholds-reset.yml @@ -22,7 +22,7 @@ name: Bencher thresholds reset # cancel by removing it before merge. Naming convention: one label per token, # `bencher-thresholds-reset:` where is a workload (a backend # testbed in Ix/Cli/BenchCmd.lean (backendSpecs) minus its runner-arch suffix: -# `ix-compile`, `ix-decompile`, `aiur-check-execute`, `aiur-check-prove`, `aiur-check-recursive`, `aiur-recursive`, `aiur-shard`, `zisk-check-execute`, `sp1-check-execute`, `ooc-check`) or +# `ix-compile`, `ix-decompile`, `aiur-check-execute`, `aiur-check-prove`, `aiur-check-recursive`, `aiur-recursive`, `zisk-check-execute`, `sp1-check-execute`, `ooc-check`) or # `all` (the merge step expands an `all` label into every workload). Labeling # requires Triage+, so PR authors from forks cannot self-queue a reset. The # label shares the command/workflow name; the ref it moves is @@ -44,7 +44,7 @@ on: # GitHub requires literal choice options, so this list stays static: # keep it (and the jobs' valid= lists below) in sync with the # backend testbeds in Ix/Cli/BenchCmd.lean (backendSpecs). - options: [ix-compile, ix-decompile, aiur-check-execute, aiur-check-prove, aiur-check-recursive, aiur-recursive, aiur-shard, zisk-check-execute, sp1-check-execute, ooc-check, all] + options: [ix-compile, ix-decompile, aiur-check-execute, aiur-check-prove, aiur-check-recursive, aiur-recursive, zisk-check-execute, sp1-check-execute, ooc-check, all] sha: description: "Commit to anchor to (default: HEAD)" required: false @@ -77,7 +77,7 @@ jobs: # (backendSpecs) minus the runner-arch suffix. Static because this # job runs on a cheap runner with no built `ix`; keep in sync when # adding a backend. - valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive aiur-shard ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" + valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" if [ "$EVENT" = workflow_dispatch ]; then # Reset the chosen workload(s) at the given commit; no PR scan. sha="${INPUT_SHA:-$HEAD_SHA}" @@ -133,7 +133,7 @@ jobs: # which the merge job expands into every workload). Same static # list as the reset job; keep both in sync with backendSpecs in # Ix/Cli/BenchCmd.lean. - valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive aiur-shard ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" + valid="aiur-check-execute aiur-check-prove aiur-check-recursive aiur-recursive ix-compile ix-decompile ooc-check sp1-check-execute zisk-check-execute" accepted="$valid all" # Parse the workload token(s) after the command, lowercased. workloads=$(printf '%s' "$BODY" \ diff --git a/Ix/Cli/AddrOfCmd.lean b/Ix/Cli/AddrOfCmd.lean index c6fb5076e..839048a2b 100644 --- a/Ix/Cli/AddrOfCmd.lean +++ b/Ix/Cli/AddrOfCmd.lean @@ -1,12 +1,15 @@ /- - `ix addr-of [--ixe ]`: resolve a Lean.Name to its - 32-byte content address. Without `--ixe`, the lookup compiles the - name's transitive closure from the compiled-in Lean env (via - `IxVM.ClaimHarness.loadIxonEnv` → `lookupAddr`). With `--ixe`, the + `ix addr-of [--ixe ] [--ixes ]`: resolve a + Lean.Name to its 32-byte content address. Without `--ixe`, the lookup + compiles the name's transitive closure from the compiled-in Lean env + (via `IxVM.ClaimHarness.loadIxonEnv` → `lookupAddr`). With `--ixe`, the lookup reads the env from disk and dispatches `Ixon.Env.getAddr?`. Prints the resulting address hex on stdout (one line, no prefix), so the output can be piped into `ix claim check $(ix addr-of …)` etc. + With `--ixes` (requires `--ixe`), a second line reports which shard of + the manifest's partition owns the name's check-schedule block — the + shard whose prove type-checks this constant. -/ module public import Cli @@ -16,6 +19,7 @@ public import Ix.Environment public import Ix.IxVM.ClaimHarness public import Ix.Ixon public import Ix.Meta +public import Ix.Cli.CheckCmd public import Ix.Cli.NameResolve public section @@ -42,7 +46,33 @@ def runAddrOfCmd (p : Cli.Parsed) : IO UInt32 := do | none => IO.eprintln s!"error: {name} not found in {path}"; return 1 | some addr => - IO.println (toString addr); return 0 + IO.println (toString addr) + if let some manifestPath := (p.flag? "ixes").map (·.as! String) then + -- Owning-shard lookup: the constant's check-schedule block (a + -- projection collapses to its SCC/Muts wrapper), searched in the + -- manifest's owned-block lists. + let c? : Option Ixon.Constant := Id.run do + for (a, lc) in ixonEnv.consts do + if a == addr then return lc.get? + return none + let some c := c? + | IO.eprintln s!"error: {addr} has no parseable constant in {path}" + return 1 + let block := Ix.Cli.CheckCmd.blockAddrOf addr c + match Ix.Cli.CheckCmd.parseIxesShards + (← IO.FS.readBinFile manifestPath) with + | .error e => + IO.eprintln s!"error: {manifestPath}: {e}"; return 1 + | .ok shards => + match (shards.mapIdx (fun k s => (s, k))).find? + (fun (s, _) => s.blocks.contains block) with + | some (s, k) => + IO.println s!"block {block} → shard {k} \ + ({s.blocks.size} blocks, cost {s.cost})" + | none => + IO.println s!"block {block} → no owning shard \ + (excluded from the partition)" + return 0 | none => let env ← get_env! if !env.constants.contains name then @@ -62,6 +92,7 @@ def addrOfCmd : Cli.Cmd := `[Cli| FLAGS: "ixe" : String; "Path to a serialized `.ixe` env to resolve the name in. Without this, the name is looked up in the compiled-in Lean env (via `loadIxonEnv` → `lookupAddr`)." + "ixes" : String; "Path to a `.ixes` shard manifest (requires --ixe): also report which shard owns the name's check-schedule block — the shard whose prove type-checks this constant." ARGS: name : String; "Fully-qualified Lean.Name to resolve (e.g. `Nat.add_comm` or `Tests.Ix.Kernel.TutorialDefs.basicDef`)." diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean index 3c9dbe756..e52f882e5 100644 --- a/Ix/Cli/BenchCmd.lean +++ b/Ix/Cli/BenchCmd.lean @@ -133,8 +133,8 @@ structure EnvSpec where def envSpecs : List EnvSpec := [ -- Init is the Aiur shard pipeline's deliverable env (the partition the - -- full-Init proof runs over), so its planner trend line matters on its - -- own — InitStd's does not subsume it. + -- full-Init proof runs over) — registered on its own even though + -- InitStd's closure contains it. { name := "Init", module := "Benchmarks/Compile/CompileInit.lean" }, { name := "InitStd", module := "Benchmarks/Compile/CompileInitStd.lean" }, { name := "Lean", module := "Benchmarks/Compile/CompileLean.lean" }, @@ -182,6 +182,13 @@ structure BackendSpec where defaultMode : String /-- The inputs (envs and row names) this backend's runs fan over. -/ inputs : BenchInputs + /-- (mode, envs): the envs whose runs in this mode ALSO measure one + whole-env row, keyed by the env name, next to the per-constant + rows (aiur execute: `ix shard .ixe --max-ram 500` — a + whole-env execution that additionally tracks the predicted fleet + partition). List an env only where the whole-env run fits the CI + host in that mode. -/ + envRows : List (String × List String) := [] /-- `some reason` ⇒ `parse` skips the backend with the note in the config summary. -/ disabled : Option String := none @@ -235,11 +242,28 @@ def backendSpecs : List BackendSpec := [ ("execute", "aiur-check-execute-x64-32x"), ("recursive", "aiur-check-recursive-x64-32x")], unscheduled := ["recursive"], + -- The execute run also measures a whole-env row per envRows env: the + -- FULL check schedule through the codegen'd kernel via `ix shard`'s + -- measured scan — the regime the single-constant rows never enter (a + -- per-constant run faults a tiny closure). The scan IS a whole-env + -- execution; the cut on top is an in-memory merge over the collected + -- block records, so `execute-time` stays an execution wall while the + -- row also tracks the partition predicted for the prove fleet at the + -- pinned `aiurShardBudgetGb`: the shard count (plotted — a packer or + -- kernel win is the only legitimate mover) and the env's total + -- measured fft-cost, which joins the per-constant series on the + -- "Aiur FFT Cost" plot (the execute testbed carries the canonical + -- fft trend; the prove-side duplicate is the unplotted copy). + -- InitStd and Lean + -- only: the heaviest envs whose execute-only wall fits a CI job + -- (Mathlib/FLT hit the dense-core multi-hour execution floor), while + -- Init's execution is contained in InitStd's. + envRows := [("execute", ["InitStd", "Lean"])], metrics := [("prove", ["prove-time", "throughput", "peak-rss", "execute-time", "verify-time", "proof-size", "fft-cost"]), ("execute", ["execute-time", "throughput", "peak-rss", - "fft-cost"]), + "fft-cost", "shards"]), ("recursive", ["recursive-prove-time", "recursive-peak-rss", "recursive-proof-size", "recursive-verify-time", "recursive-execute-time", "recursive-fft-cost", @@ -248,9 +272,15 @@ def backendSpecs : List BackendSpec := [ -- upper-only 5% instead of a hard pin. peak-rss and throughput are -- phase-scoped by the CELL (execute vs prove testbed); -- prove/verify-time and proof-size exist only on the prove testbed. + -- shards exists only on the whole-env execute rows: shard count can + -- only legitimately drop (a packer or kernel win), so it pins upper + -- at 0. (The heaviest shard's own cost is NOT tracked: any repack + -- reshapes it, so a band on it alerts on shard shape, not + -- regressions.) thresholds := [("constants", "0", "0"), ("fft-cost", "0.05", "_"), ("prove-time", "0.10", "_"), ("verify-time", "0.10", "_"), ("proof-size", "0.05", "_"), ("execute-time", "0.10", "_"), + ("shards", "0", "_"), ("peak-rss", "0.10", "_"), ("throughput", "_", "0.10")] }, -- The aiur-recursive run (bench-typecheck --recursive over -- `recursiveConstants`): IxVM recursion on real statements — prove each @@ -278,28 +308,6 @@ def backendSpecs : List BackendSpec := [ ("recursive-proof-size", "0.05", "_"), ("prove-time", "0.10", "_"), ("proof-size", "0.05", "_"), ("verify-time", "0.10", "_"), ("peak-rss", "0.10", "_")] }, - -- The Aiur shard pipeline: one whole-env measured scan (`ix shard - -- scan`) at the pinned budget (`aiurShardBudgetGb`) — the FULL check - -- schedule executes through the codegen'd kernel as thin-frontier - -- CheckEnv claims with a running FFT readout, so the row tracks the - -- regime the per-constant aiur rows never enter (a single-constant run - -- faults a tiny closure). scan-time is the whole-env execution wall, - -- peak-rss the scan process tree's high-water; shards and the measured - -- max/total per-shard cost come from the manifest the scan writes. - -- fft-cost is the env's TOTAL measured fft — the same raw unit and - -- slug as the per-constant aiur rows, so the whole-env series joins - -- the existing Aiur FFT cost plot. The scan is deterministic — identical partitions across runs - -- on Init and InitStd — so the count and cost slugs ride 0/2% upper - -- bands: a regression can only move them up, and a legitimate kernel or - -- packer win lowers them freely. - { name := "aiur-shard", defaultMode := "execute", inputs := .perEnv, - testbeds := [("execute", "aiur-shard-x64-32x")], - metrics := [("execute", ["scan-time", "peak-rss", "shards", - "max-shard-fft", "fft-cost"])], - thresholds := [("shards", "0", "_"), ("max-shard-fft", "0.02", "_"), - ("fft-cost", "0.02", "_"), - ("scan-time", "0.10", "_"), - ("peak-rss", "0.10", "_")] }, { name := "zisk", defaultMode := "execute", inputs := .perConstant, testbeds := [("execute", "zisk-check-execute-x64-32x")], metrics := [("execute", ["execute-time", "throughput", "peak-rss", @@ -383,13 +391,14 @@ def findBackend (name : String) : Option BackendSpec := def recursiveConstants : List String := ["Nat.add_comm"] -/-- `aiur-shard`'s pinned packing budget (GiB). Machine-independent on - purpose: a PR row and its bencher baseline must describe the same - partition problem, so the budget is the deliverable 256 GB prove - box — NOT the runner's own RAM (`--ceiling-gb` still guards the - runner). Executing a shard needs a small fraction of its predicted - PROVE RAM, so heavy-three execution fits hosts the prove would not. -/ -def aiurShardBudgetGb : Nat := 250 +/-- The whole-env execute rows' pinned packing budget (GiB): `ix shard + .ixe --max-ram` for the partition the row tracks. Machine- + independent on purpose — a PR row and its bencher baseline must + describe the same partition problem, so the budget is the deliverable + 500 GB prove-fleet box, NOT the runner's own RAM. The budget is only + the cut threshold: the scan executes with a pool sized to the + runner's actual RAM (`--ceiling-gb` still guards it). -/ +def aiurShardBudgetGb : Nat := 500 def BackendSpec.testbedFor (b : BackendSpec) (mode : String) : Option String := (b.testbeds.find? (·.1 == mode)).map (·.2) @@ -397,6 +406,10 @@ def BackendSpec.testbedFor (b : BackendSpec) (mode : String) : Option String := def BackendSpec.metricsFor (b : BackendSpec) (mode : String) : List String := ((b.metrics.find? (·.1 == mode)).map (·.2)).getD [] +/-- The envs whose runs in `mode` measure a whole-env row (`envRows`). -/ +def BackendSpec.envRowEnvs (b : BackendSpec) (mode : String) : List String := + ((b.envRows.find? (·.1 == mode)).map (·.2)).getD [] + /-- `thresholds` rendered as the bencher-track action's `--threshold-*` flags, one percentage-test triple per measure. `__WINDOW__` is the action's placeholder for the per-workload baseline window (data points @@ -421,7 +434,8 @@ def BackendSpec.scheduledModes (b : BackendSpec) : List String := constant excluded from one mode (e.g. prove) still keeps its env if another scheduled mode (e.g. execute) runs it; the fixed-config backend is env-independent, pinned to the head env so CI schedules - exactly one entry. -/ + exactly one entry. An env with a whole-env row (`envRows`) in a + scheduled mode is covered like one with selected constants. -/ def BackendSpec.envNames (b : BackendSpec) (rows : Array VectorRow) : List String := let names := envSpecs.map (·.name) @@ -430,6 +444,7 @@ def BackendSpec.envNames (b : BackendSpec) (rows : Array VectorRow) : | .perConstant | .perConstantWithEnv => names.filter fun env => b.scheduledModes.any fun m => + (b.envRowEnvs m).contains env || !(selectNames rows env b.name m (full := false) (tier := "") (shardOnly := false)).isEmpty | .fixedConfigs => names.take 1 @@ -449,7 +464,8 @@ def BackendSpec.benchmarkNames (b : BackendSpec) (rows : Array VectorRow) | .perConstant | .perConstantWithEnv => let mut ns : Array String := #[] for env in b.envNames rows do - if b.inputs == .perConstantWithEnv then ns := ns.push env + if b.inputs == .perConstantWithEnv + || (b.envRowEnvs mode).contains env then ns := ns.push env ns := ns ++ (selectNames rows env b.name mode (full := false) (tier := "") (shardOnly := false)).map (·.name) return ns @@ -813,6 +829,49 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do IO.eprintln s!"[bench] per-constant closures failed (exit {exit})" | "aiur" => let ixe ← ensureIxe repo info ((p.flag? "ixe").map (·.as! String)) + -- Whole-env row (keyed by the env name) on the mode's `envRows` envs: + -- the FULL check schedule through the codegen'd kernel via `ix + -- shard`'s measured scan, which cuts the partition predicted for the + -- prove fleet at `aiurShardBudgetGb` on the way (an in-memory merge + -- over the block records the execution already collected — no second + -- execution, no re-price). The tool self-reports execute-time / + -- peak-rss through the rows contract (env load excluded from the + -- timed window, RSS = process-tree high-water, covering the worker + -- pool); shards, max-shard-fft, and the env's total fft-cost come + -- from the manifest. A kill (≥128) records `oom`/`crash` — the + -- honest row for a box the env no longer fits; a kernel reject exits + -- nonzero with no row and the gate fails on the missing row. + -- Skipped under a `--consts` override — a targeted run stays + -- targeted. + if wanted.isEmpty && (spec.envRowEnvs mode).contains env then + let ix ← resolveBin repo "ix" + let manifest := s!"{repo}/{env}-shardbench.ixes" + let exit ← runGuarded watchdog ceilingGb ix + #["shard", ixe, "--max-ram", toString aiurShardBudgetGb, + "--out", manifest, "--json", out, "--json-name", info.name] + if exit ≥ 128 then + let status := killStatus exit + IO.eprintln s!"[bench] whole-env scan killed (exit {exit}); recording {status}" + markKilled out info.name status + else if exit != 0 then + IO.eprintln s!"[bench] ix shard scan failed (exit {exit})" + else + -- Partition metrics straight from the manifest's tagged costs + -- (measured fft): count and total — the deterministic trend + -- lines a kernel or packer change moves. + match Ix.Cli.CheckCmd.parseIxesShards (← IO.FS.readBinFile manifest) with + | .error e => IO.eprintln s!"[bench] manifest parse failed: {e}" + | .ok shardRows => + if shardRows.isEmpty then + IO.eprintln s!"[bench] empty partition in {manifest}" + else + let totalFft := shardRows.foldl (fun s r => s + r.cost) 0 + let rows ← readRows out + if let some envRow := (rows.getObjVal? info.name).toOption then + writeEntry out info.name <| + (envRow.setObjVal! "shards" + (Lean.toJson shardRows.size)).setObjVal! + "fft-cost" (Lean.toJson totalFft) let bt ← resolveBin repo "bench-typecheck" let modeArgs := match mode with | "execute" => #["--execute-only"] @@ -838,52 +897,6 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do runGuarded watchdog ceilingGb bt #["--ixe", ixe, "--consts", name, "--json", out, "--texray", "--recursive"] - | "aiur-shard" => - if mode != "execute" then - p.printError s!"error: {backend} supports only execute mode" - return exitUsage - let ixe ← ensureIxe repo info ((p.flag? "ixe").map (·.as! String)) - let ix ← resolveBin repo "ix" - let manifest := s!"{repo}/{env}-shardbench.ixes" - let budget := (p.flag? "shard-budget").map (·.as! Nat) - |>.getD aiurShardBudgetGb - -- One whole-env measured scan: executes the entire check schedule as - -- thin-frontier CheckEnv claims and writes the manifest with MEASURED - -- per-shard fft. The tool self-reports scan-time/peak-rss through - -- the rows contract (env load excluded from the timed window, RSS = - -- process-tree high-water). A kill (≥128) records `oom`/`crash` — the - -- honest row for a box the scan no longer fits; any other nonzero - -- exit is a genuine kernel rejection and fails the run. - let exit ← runGuarded watchdog ceilingGb ix - #["shard", ixe, "--max-ram", toString budget, - "--out", manifest, "--json", out, "--json-name", info.name] - if exit ≥ 128 then - let status := killStatus exit - IO.eprintln s!"[bench] scan killed (exit {exit}); recording {status}" - markKilled out info.name status - return 0 - if exit != 0 then - IO.eprintln s!"[bench] ix shard scan failed (exit {exit})" - return 1 - -- Partition metrics straight from the manifest's tagged costs - -- (measured fft): count, heaviest shard, and the total — the - -- deterministic trend lines a kernel or packer change moves. - match Ix.Cli.CheckCmd.parseIxesShards (← IO.FS.readBinFile manifest) with - | .error e => - IO.eprintln s!"[bench] manifest parse failed: {e}" - return 1 - | .ok shardRows => - if shardRows.isEmpty then - IO.eprintln s!"[bench] empty partition in {manifest}" - return 1 - let maxFft := shardRows.foldl (fun m r => max m r.cost) 0 - let totalFft := shardRows.foldl (fun s r => s + r.cost) 0 - let rows ← readRows out - if let some envRow := (rows.getObjVal? info.name).toOption then - writeEntry out info.name <| - ((envRow.setObjVal! "shards" (Lean.toJson shardRows.size)).setObjVal! - "max-shard-fft" (Lean.toJson maxFft)).setObjVal! - "fft-cost" (Lean.toJson totalFft) | "zisk" | "sp1" => if mode != "execute" then p.printError s!"error: {backend} supports only execute mode" @@ -935,10 +948,13 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do let expected := match backend with | "compile" => #[info.name] | "decompile" => #[info.name] - | "aiur-shard" => #[info.name] | "ooc" | "lean4lean" => #[info.name] ++ names | "aiur-recursive" => recursiveConstants.toArray - | _ => names + | _ => + -- An `envRows` env owes its whole-env row too (unless a --consts + -- override targeted the run). + if wanted.isEmpty && (spec.envRowEnvs mode).contains env + then #[info.name] ++ names else names let code ← gate out expected if code == 0 || code == exitRejected then saveBaseline out s!"{backend}-{env}-{mode}" @@ -980,7 +996,7 @@ def benchRunCmd : Cli.Cmd := `[Cli| "Execute one benchmark run (backend × env × mode), writing benchmark results JSON. Exits 0 on success (rows saved as the local baseline), 3 when the kernel rejected any constant, 1 when no rows were produced." FLAGS: - backend : String; "aiur | aiur-shard | zisk | sp1 | ooc | lean4lean | compile | decompile | aiur-recursive" + backend : String; "aiur | aiur-recursive | zisk | sp1 | ooc | lean4lean | compile | decompile" env : String; "Benchmark env from the registry (default: InitStd)" mode : String; "prove | execute | recursive (default: the backend's defaultMode)" out : String; "Benchmark results JSON output path (default: bench.json)" @@ -992,7 +1008,6 @@ def benchRunCmd : Cli.Cmd := `[Cli| "shard-only"; "Restrict to shard_target rows" ixe : String; "Path to an existing .ixe env to use (default: compile fresh; ignored by the compile backend)" "ceiling-gb" : Nat; "RAM watchdog ceiling in GB (default: machine RAM minus 15 GB)" - "shard-budget" : Nat; "aiur-shard only: pinned `ix shard --max-ram` budget in GiB (default 250, the deliverable prove box). Change it only knowingly — the bencher baseline is keyed to the same partition problem." watchdog : String; "Watchdog wrapper path (default: /.github/scripts/watchdog.sh; missing = run unguarded)" ] diff --git a/Ix/Cli/BenchPlots.lean b/Ix/Cli/BenchPlots.lean index 361daaea0..eb06e76a2 100644 --- a/Ix/Cli/BenchPlots.lean +++ b/Ix/Cli/BenchPlots.lean @@ -64,10 +64,11 @@ def plotTitle (workload measure : String) : String := | "aiur-check-prove", "peak-rss" => "Aiur Prove Peak RAM Usage" | "aiur-check-prove", "verify-time" => "Aiur Verify Time" | "aiur-check-prove", "proof-size" => "Aiur Proof Size" - | "aiur-check-prove", "fft-cost" => "Aiur FFT Cost" + | "aiur-check-execute", "fft-cost" => "Aiur FFT Cost" | "aiur-check-execute", "execute-time" => "Aiur Execute Time" | "aiur-check-execute", "throughput" => "Aiur Execute Throughput" | "aiur-check-execute", "peak-rss" => "Aiur Execute Peak RAM Usage" + | "aiur-check-execute", "shards" => "Aiur Predicted Shards" | "zisk-check-execute", "execute-time" => "Zisk Execute Time" | "zisk-check-execute", "throughput" => "Zisk Execute Throughput" | "zisk-check-execute", "peak-rss" => "Zisk Execute Peak RAM Usage" @@ -81,16 +82,15 @@ def plotTitle (workload measure : String) : String := | "aiur-recursive", "recursive-peak-rss" => "Aiur Recursive Verifier Peak RAM Usage" | "aiur-recursive", "recursive-proof-size" => "Aiur Recursive Verifier Proof Size" | "aiur-recursive", "recursive-fft-cost" => "Aiur Recursive Verifier FFT Cost" - | "aiur-shard", "shards" => "Aiur Predicted Shards" - | "aiur-shard", "union-bytes" => "Aiur Shard Ingress Bytes" - | "aiur-shard", "heavy-execute-time" => "Aiur Heavy-Shard Execute Time" - | "aiur-shard", "heavy-peak-rss" => "Aiur Heavy-Shard Peak RAM Usage" | w, m => s!"{w}: {m}" /-- Tracked but not plotted solo. The two aiur runs re-measure each other's deterministic Phase-1 numbers as a redundancy check — one - trend line each is enough ("Aiur Execute Time" from the execute run, - "Aiur FFT Cost" from the prove run). Zisk `shards` is charted below + trend line each is enough, and both live on the execute testbed + ("Aiur Execute Time", "Aiur FFT Cost"), where the whole-env rows + upload too — so the env series and the per-constant series share + the same plots. The prove run's duplicates (execute-time, fft-cost) + are the skipped copies. Zisk `shards` is charted below over the heavy-tier primaries alone (light constants are pinned at a single shard, a flat line at 1), not over the full set here; zisk `constants` charts on the input-constants plot below instead of alone. @@ -102,17 +102,13 @@ def plotTitle (workload measure : String) : String := IxVM typecheck proof (under recursion-tuned parameters) — tracked for the compare table, but the dashboard trend that matters is the recursion layer's own `recursive-*` series, so the inner metrics - aren't plotted. aiur-shard's - `pred-floor-ram` is a cap-overflow tripwire (thresholded), while the - heavy-three execution charts the real RAM — the prediction adds no - dashboard trend of its own. -/ + aren't plotted. -/ def plotSkips : List (String × String) := - [("aiur-check-prove", "execute-time"), ("aiur-check-execute", "fft-cost"), + [("aiur-check-prove", "execute-time"), ("aiur-check-prove", "fft-cost"), ("zisk-check-execute", "shards"), ("zisk-check-execute", "constants"), ("ix-decompile", "file-size"), ("ix-decompile", "constants"), ("aiur-recursive", "prove-time"), ("aiur-recursive", "proof-size"), - ("aiur-recursive", "verify-time"), ("aiur-recursive", "peak-rss"), - ("aiur-shard", "pred-floor-ram")] + ("aiur-recursive", "verify-time"), ("aiur-recursive", "peak-rss")] /-- Canonical units per measure slug, asserted on every sync: bencher auto-creates a measure with placeholder units ("Measure (units)") on @@ -135,10 +131,6 @@ def unitsFor (slug : String) : Option String := ("cycles", "cycles"), ("max-shard-cycles", "cycles"), ("shards", "shards"), - ("pred-floor-ram", "GiB"), - ("union-bytes", "bytes (B)"), - ("heavy-execute-time", "seconds (s)"), - ("heavy-peak-rss", "bytes (B)"), ("fft-cost", "FFTs"), ("recursive-execute-time", "seconds (s)"), ("recursive-prove-time", "seconds (s)"), @@ -152,7 +144,7 @@ def unitsFor (slug : String) : Option String := ooc); unranked workloads (a future backend) sort last. -/ def workloadOrder : List String := ["ix-compile", "ix-decompile", "aiur-check-prove", "aiur-check-execute", - "aiur-recursive", "aiur-shard", "zisk-check-execute", "ooc-check"] + "aiur-recursive", "zisk-check-execute", "ooc-check"] structure PlotSpec where testbed : String diff --git a/Ix/Cli/BenchReport.lean b/Ix/Cli/BenchReport.lean index 9a397a8b6..2dad7789e 100644 --- a/Ix/Cli/BenchReport.lean +++ b/Ix/Cli/BenchReport.lean @@ -822,8 +822,11 @@ def runMatrixCmd (p : Cli.Parsed) : IO UInt32 := do -- an env stays in `envNames` because some scheduled mode runs it, -- but a constant excluded from one mode (e.g. Lean's only primary -- constant is prove-excluded) leaves that (env, mode) cell empty — - -- scheduling it would waste a job and expect a row that never lands. + -- scheduling it would waste a job and expect a row that never + -- lands. A whole-env row (`envRows`) keeps the cell scheduled + -- even with no per-constant selection. if b.inputs == .perConstant + && !(b.envRowEnvs mode).contains env && (Ix.Cli.BenchCmd.selectNames rows env b.name mode (full := false) (tier := "") (shardOnly := false)).isEmpty then continue @@ -868,7 +871,8 @@ def parseError (msg : String) : IO UInt32 := do Grammar (an unknown command-line token, or an unknown env in BENCH_ENVS, rejects the command — exit 2 and a `parse-error` output): - !benchmark ([aiur] [zisk] [sp1] [ooc] [compile] [aiur-recursive] | all) + !benchmark ([aiur] [aiur-recursive] [zisk] [sp1] [ooc] [compile] + [decompile] | all) [execute | recursive] [fresh] [KEY=VALUE …] BENCH_ENVS=InitStd,Mathlib (case-insensitive, any registry env; defaults to every env for the diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 974a6b0a5..861f902bc 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -422,8 +422,9 @@ def parseIxesAllShards (bytes : ByteArray) : Except String (Array (Array Address /-- The check-schedule block address of a constant: a projection collapses to its SCC/Muts wrapper (`p.block`); everything else is its own block. - Mirrors `check_schedule_block_addr` (`src/ffi/kernel.rs`). -/ -private def blockAddrOf (addr : Address) (c : Ixon.Constant) : Address := + Mirrors `check_schedule_block_addr` (`src/ffi/kernel.rs`). Public for + `ix addr-of --ixes`' owning-shard lookup. -/ +def blockAddrOf (addr : Address) (c : Ixon.Constant) : Address := match c.info with | .iPrj prj => prj.block | .cPrj prj => prj.block @@ -523,12 +524,12 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 | .ok h => pure h - -- `benchJson = (out, rowName)` reports the check as a benchmark row - -- (the `aiur-shard` bench backend's per-shard spawn): `execute-time` - -- windows the check itself — the env parse and `EnvHandle` build are - -- excluded, so the measure tracks the kernel, not the loader — while - -- `peak-rss` is the process tree's absolute high-water (the parsed - -- env sits in the baseline, matching the ooc rows' semantics). + -- `benchJson = (out, rowName)` reports the check as a benchmark + -- row: `execute-time` windows the check itself — the env parse and + -- `EnvHandle` build are excluded, so the measure tracks the + -- kernel, not the loader — while `peak-rss` is the process tree's + -- absolute high-water (the parsed env sits in the baseline, + -- matching the ooc rows' semantics). if benchJson.isSome then TracingTexray.startSampler TracingTexray.resetPeakTreeRss @@ -695,13 +696,31 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | .ok h => pure h let workers := (p.flag? "jobs").map (·.as! Nat) |>.getD 0 let workerBin := (← IO.appPath).toString + -- `--json` reports the run as a benchmark row: `execute-time` + -- windows the parallel check itself — the kernel compile and + -- `EnvHandle` build are excluded, so the measure tracks the kernel, + -- not the loader — while `peak-rss` is the process tree's absolute + -- high-water (covers the worker pool). + let benchJson := (p.flag? "json").map fun f => + (f.as! String, + ((p.flag? "json-name").map (·.as! String)).getD "execute") + if benchJson.isSome then + TracingTexray.startSampler + TracingTexray.resetPeakTreeRss let start ← IO.monoMsNow match Aiur.Bytecode.Toplevel.executeEnvWithEnv compiled.bytecode funIdx envHandle (toString workers) (if keepGoing then "0" else "1") workerBin ixe with | .error e => IO.eprintln s!"execute failed: {e}"; return 1 | .ok () => - IO.println s!"execute: OK in {(← IO.monoMsNow) - start} ms" + let ms := (← IO.monoMsNow) - start + IO.println s!"execute: OK in {ms} ms" + if let some (out, rowName) := benchJson then + let peakRss ← TracingTexray.peakTreeRssBytes + Ix.Benchmark.Results.writeRow out rowName "ok" + [ ("execute-time", + Ix.Benchmark.Results.jsonRound 3 (ms.toFloat / 1000.0)) + , ("peak-rss", Lean.toJson peakRss) ] return 0 let claimHex : Option String := (p.flag? "claim").map (·.as! String) @@ -789,8 +808,8 @@ def checkCmd : Cli.Cmd := `[Cli| "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; "Max shards to check concurrently when checking a whole partition (--ixes without --shard). Default: all at once. Lower it to bound peak RAM — each in-flight shard re-ingests its closure into its own IO buffer." - json : String; "Benchmark results JSON accumulator (single-shard mode only): append an `execute-time`/`peak-rss` row for the checked shard. Used by `ix bench run --backend aiur-shard`." - "json-name" : String; "Row name for --json (default: shard-)." + json : String; "Benchmark results JSON accumulator (single-shard and --execute modes): append an `execute-time`/`peak-rss` row for the checked shard or whole-env execute." + "json-name" : String; "Row name for --json (default: shard-, or `execute` for --execute)." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to check. With none, iterate every named constant in the env (sorted)." From e1a6f27fb165538eafa05cee25ef9d1c05566698 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Fri, 7 Aug 2026 22:11:32 +0000 Subject: [PATCH 19/20] =?UTF-8?q?scan:=20union=20pricing=20=E2=80=94=20per?= =?UTF-8?q?-circuit=20membership=20sketches=20replace=20the=20cold=20re-pr?= =?UTF-8?q?ice?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A shard's true cold cost is the cost of the union of its segments' records (per-query cost is context-free), so each segment ships a per-circuit membership sketch built from the record's stored entry hashes — exact lists up to 1024 uniques, 8 KB HyperLogLog registers above — and the merge unions sketches, feeds the estimated union heights to the analytic cost/RAM model, and cuts directly at the budget. Manifest fft moves to the 539-grounded formula (AiurSystem::fft_cost_from_raws, the Rust mirror of Statistics.lean). The cold re-price pass, PACK_OVERSHOOT, the PRICE worker verb, price files, and --reprice are deleted. Validated on recompiled Init/InitStd/Lean @500 GiB: 11/18/28 shards (re-priced baselines cut 9/19/27) at unchanged scan walls; heaviest shards prove green. Known follow-up: the union keeps per-claim assumption/boundary entries the prove's single claim never pays (measured 1.26x on an InitStd shard), so estimates run ~25% high — counts still land at re-price level because 541+539 shrank true content by a similar factor. --- Ix/Cli/ShardCmd.lean | 14 +- crates/aiur/src/querymap.rs | 21 + crates/aiur/src/synthesis.rs | 126 +- crates/ffi/src/aiur/scan.rs | 800 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 18145 +++++++++++++------------ 5 files changed, 9678 insertions(+), 9428 deletions(-) diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index 9daa256af..e5f228270 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -79,11 +79,6 @@ def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do -- names in `.failed-names.txt`. Implies --no-fail-fast; the -- mode reaches the scanner as fail-fast mode string "2". let deferInfeasible := p.hasFlag "defer-infeasible" - -- Cold re-price (opt-in): replace summed shard costs with one - -- measured cold execution per merged shard, packing past the cut by - -- the validated slack. Adopt per env only after its re-priced - -- manifest passes the heaviest-shard prove protocol. - let reprice := p.hasFlag "reprice" let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 | .ok t => pure t @@ -118,16 +113,14 @@ def runShardScan (p : Cli.Parsed) (ixePath : String) : IO UInt32 := do -- build cost (preprocessed gadget commit) is seconds against a -- minutes-scale scan. let system := Aiur.AiurSystem.build compiled.bytecode - Aiur.productionCommitmentParameters Aiur.productionFriParameters + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters -- Process-pool mode: the scan spawns ` shard-worker` -- children under cgroup memory caps, so an over-cap worker is -- OOM-killed alone and recovered, never the box. let workerBin := (← IO.appPath).toString match Aiur.AiurSystem.scanShardsWithEnv system funIdx envHandle (toString budget) (toString eps) (toString workers) - (if deferInfeasible && reprice then "4" - else if reprice then "3" - else if deferInfeasible then "2" + (if deferInfeasible then "2" else if noFailFast then "0" else "1") outPath workerBin ixePath with @@ -302,7 +295,7 @@ def runShardWorkerCmd (p : Cli.Parsed) : IO UInt32 := do | some i => pure i | none => IO.eprintln "error: verify_claim missing"; return 1 let system := Aiur.AiurSystem.build compiled.bytecode - Aiur.productionCommitmentParameters Aiur.productionFriParameters + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters let envHandle ← match Aiur.EnvHandle.fromIxe ixe with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h @@ -329,7 +322,6 @@ def shardCmd : Cli.Cmd := `[Cli| workers : Nat; "Scan only: parallel chunk scanners (default 0 = autoscale to cores and detected RAM). Each holds one segment's query record and faulted witness, so workers × segment footprint must fit the box" "fail-fast"; "Scan: halt on the first kernel-rejected block (the default; flag accepted for explicitness)." "no-fail-fast"; "Scan: skip kernel-rejected blocks (named as skipped, excluded from the partition, listed in .failed.csv). The manifest then does not cover them — the downstream coverage gate reports exactly which." - "reprice"; "Scan: cold re-price — pack past the cut on summed costs, then measure each merged shard's true cost with one cold CheckEnv execution (splits over-cut shards). Opt-in; validate per env by proving the heaviest re-priced shard before adopting its manifest." "defer-infeasible"; "Scan: name deferred dense regions (opening cone exceeds a fleet slot) resource-infeasible instead of walking them under fat caps, and resolve the whole exclusion inventory to Lean names in .failed-names.txt. Implies --no-fail-fast. The partition covers only tractable content; failed.csv + failed-names.txt carry the exact boundary." json : String; "Scan only: benchmark results JSON accumulator — append an `execute-time`/`peak-rss` row (the scan wall is a whole-env execution wall). Used by `ix bench run --backend aiur` for the whole-env execute row." "json-name" : String; "Row name for --json (default: scan)." diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 7ddb8b91f..81576f1d4 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -218,6 +218,19 @@ impl SegHashes { Self { segs: Vec::new(), entries: 0 } } + /// Visit every stored hash in insertion order. One sequential pass + /// over the segment arenas — no rehashing, no table walk. + fn for_each(&self, mut f: impl FnMut(u64)) { + let mut left = self.entries; + for seg in &self.segs { + let take = left.min(seg.len); + for &h in seg.slice(0, take) { + f(h); + } + left -= take; + } + } + #[inline] fn at(&self, i: usize) -> u64 { self.segs[i >> SEG_BITS].slice(i & SEG_MASK, 1)[0] @@ -295,6 +308,14 @@ impl QueryMap { self.keys.retained_elems() + self.outs.retained_elems() } + /// Visit the stored 64-bit hash of every unique entry, in insertion + /// order. The hashes are already computed and resident (they back + /// table growth), so this is a pure sequential read — the scanner's + /// union-pricing sketches are built from these without rehashing. + pub fn for_each_hash(&self, f: impl FnMut(u64)) { + self.hashes.for_each(f); + } + /// Exact heap bytes of this map's fill: arena elements, stored hashes, /// and the hash-table allocation (power-of-two buckets at 7/8 load, /// `u32` index + 1 control byte per bucket, fully resident). diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 071ae4a6b..b11b5fc66 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -210,6 +210,38 @@ impl AiurSystem { /// record's unique queries — the padding the trace actually commits, /// which per-fft models blur. pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes { + self.peak_prove_bytes_from_raws( + &self.circuit_raws(record), + crate::execute::record_retained_bytes(record), + ) + } + + /// Per-circuit raw (unpadded) trace heights of a record, in canonical + /// system order: the record's unique queries per function/memory + /// circuit, and the byte gadgets' fixed full-table heights. + pub fn circuit_raws(&self, record: &QueryRecord) -> Vec { + self + .circuit_types() + .iter() + .map(|ct| match ct { + CircuitType::Function { idx } => record.function_queries[*idx].len(), + CircuitType::Memory { width } => { + record.memory_queries.get(width).map_or(0, |m| m.len()) + }, + CircuitType::Bytes1 => 256, + CircuitType::Bytes2 => 65536, + }) + .collect() + } + + /// [`Self::peak_prove_bytes`] from per-circuit raw heights and a record + /// byte count directly — the scanner's union pricing feeds ESTIMATED + /// union heights of a merged shard here, where no single record exists. + pub fn peak_prove_bytes_from_raws( + &self, + raws: &[usize], + record_bytes: usize, + ) -> PeakProveBytes { const S: usize = 8; // bytes per base field element (Goldilocks) const DG: usize = 32; // blake3 digest bytes (Merkle nodes, arity 2) let b = 1usize << self.commitment_parameters.log_blowup; @@ -222,15 +254,8 @@ impl AiurSystem { let mut committed = 0usize; // all committed LDE bytes let mut prep = 0usize; let mut tallest = 0usize; - for (i, ct) in self.circuit_types().iter().enumerate() { - let raw = match ct { - CircuitType::Function { idx } => record.function_queries[*idx].len(), - CircuitType::Memory { width } => { - record.memory_queries.get(width).map_or(0, |m| m.len()) - }, - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - }; + for (i, &raw) in raws.iter().enumerate().take(self.system.circuits.len()) + { if raw == 0 { continue; } @@ -251,7 +276,6 @@ impl AiurSystem { + 2 * DG * b * c.preprocessed_height; } let h = b * tallest; - let record_bytes = crate::execute::record_retained_bytes(record); let phase_witness = record_bytes + witness; let phase_stage2 = s1_lde + 2 * DG * h + lookup_w + msgs + s2_trace; // Trees (3 rounds) + retained FRI fold layers + open buffers, all ∝ H. @@ -266,6 +290,88 @@ impl AiurSystem { } } + /// Model a (possibly merged) execution from per-map unique-entry + /// estimates instead of a live record — the scanner's union pricing: + /// each element is `(is_function, id, est_raw, est_elems)` where `id` + /// is a function index or a memory width, `est_raw` the estimated + /// unique queries of the union, and `est_elems` its retained field + /// elements. Unconstrained-function maps carry no circuit and + /// contribute only record bytes, exactly as in a live record. Returns + /// the same `(fft, peak-prove-bytes)` pair a single cold record of the + /// union would produce. + pub fn model_from_map_estimates( + &self, + ests: &[(bool, usize, usize, usize)], + ) -> (f64, PeakProveBytes) { + let mut raws = vec![0usize; self.system.circuits.len()]; + let mut record_bytes = 0usize; + let types = self.circuit_types(); + for &(is_function, id, est_raw, est_elems) in ests { + record_bytes += est_elems * 8 + est_raw * 21; + let pos = types.iter().position(|ct| match ct { + CircuitType::Function { idx } => is_function && *idx == id, + CircuitType::Memory { width } => !is_function && *width == id, + _ => false, + }); + if let Some(pos) = pos { + raws[pos] = est_raw; + } + } + for (i, ct) in types.iter().enumerate() { + match ct { + CircuitType::Bytes1 => raws[i] = 256, + CircuitType::Bytes2 => raws[i] = 65536, + _ => {}, + } + } + ( + self.fft_cost_from_raws(&raws), + self.peak_prove_bytes_from_raws(&raws, record_bytes), + ) + } + + /// [`Self::fft_cost_from_raws`] of a live record. + pub fn fft_cost_of_record(&self, record: &QueryRecord) -> f64 { + self.fft_cost_from_raws(&self.circuit_raws(record)) + } + + /// FFT cost of a proof at the given per-circuit raw heights — the Rust + /// mirror of the Lean model (`Ix/Aiur/Statistics.lean`, grounded in the + /// pinned prover's actual transforms): per circuit, `(B+1)` size-`h` + /// transforms per committed column (main + stage-2 + quotient chunks), + /// plus the two quotient-rebasing transforms. Raw heights stay unpadded + /// so one-row changes remain visible. The scanner's manifest costs use + /// this, so whole-env, per-shard, and per-constant fft figures share + /// one unit. + pub fn fft_cost_from_raws(&self, raws: &[usize]) -> f64 { + fn transform(x: usize) -> f64 { + if x == 0 { + 0.0 + } else { + let xf = crate::execute::f64_from_usize(x); + xf * xf.max(2.0).log2() + } + } + let b = + crate::execute::f64_from_usize(1usize << self.commitment_parameters.log_blowup); + let mut total = 0.0f64; + for (c, &raw) in self.system.circuits.iter().zip(raws) { + if raw == 0 { + continue; + } + let d = c.stage_2_width / (1 + c.num_lookups); // extension degree + let q = c.quotient_degree(); + let q_d = q * d; + let commit_w = c.main_width + c.stage_2_width + q_d; + total += (b + 1.0) + * crate::execute::f64_from_usize(commit_w) + * transform(raw) + + crate::execute::f64_from_usize(d) * transform(q * raw) + + crate::execute::f64_from_usize(q_d) * transform(raw); + } + total + } + #[tracing::instrument(level = "info", skip_all, name = "aiur/prove")] pub fn prove( &self, diff --git a/crates/ffi/src/aiur/scan.rs b/crates/ffi/src/aiur/scan.rs index 2bbea07a3..c773fd367 100644 --- a/crates/ffi/src/aiur/scan.rs +++ b/crates/ffi/src/aiur/scan.rs @@ -24,8 +24,11 @@ //! by one claim may be checked by the next — but batching divides that //! per-claim overhead by the batch size and removes intra-batch frontier //! edges entirely, so the checkpoint is a tight upper bound on the -//! emitted shard's cold cost: the safe direction for packing, accurate -//! enough to BE the manifest cost without a blanket re-price. +//! emitted SEGMENT's cold cost. Across segments the merge does not sum: +//! each segment ships a per-circuit membership sketch of its record, and +//! a shard is priced as the modeled cost of the UNION of its segments' +//! records — the same dedup the prove's single cold record performs — +//! so the manifest cost needs no cold re-price pass. //! //! Witness bytes are served LAZILY (`EnvFaultSource`): only the claim //! wires are seeded per attempt, and constant/hint/blob bytes materialize @@ -204,6 +207,11 @@ struct Segment { blocks: Vec, fft: f64, ram_gib: f64, + /// Per-circuit membership sketch of the segment's record — the union + /// pricing input. `None` in execute-only mode (no partition to price) + /// and on decode failures, where the merge falls back to summing this + /// segment conservatively. + sketch: Option, } /// Everything a chunk scanner needs besides its own chunk: kernel, env, @@ -330,23 +338,334 @@ const CLEANUP_WORKERS: usize = 12; /// record growth IS the reduction work just performed. const DEFER_GROWTH_BYTES_PER_BLOCK: f64 = 1.0e8; -/// Merge-pass packing target as a multiple of the cut. Summed segment -/// costs overstate a merged shard's true cold cost (shared cones count -/// once per segment; padded heights are subadditive) — measured -/// true/summed = 0.606-0.623 on the three heaviest 500-budget shards — -/// so packing to the cut on sums leaves ~40% of the budget unused. The -/// merge packs past the cut by this factor and the cold RE-PRICE round -/// then measures every shard's true cost (one CheckEnv execution per -/// shard, the exact claim its prove runs); the deliberate gap below the -/// measured 1.6x slack keeps over-cut re-prices (which force a split) -/// rare. -const PACK_OVERSHOOT: f64 = 1.45; - -/// Re-price round width: one cold execution per merged shard, each -/// holding only the shard's RECORD (~true prove RSS / 20), so slots are -/// pool/width ≈ 30-40 GiB — enough for every shard record plus a dense -/// opening cone. -const REPRICE_WORKERS: usize = 12; +/// Union pricing: summed segment costs overstate a merged shard's true +/// cold cost (shared cone queries count once per SEGMENT in the sum but +/// once per SHARD in the prove's single cold record — measured +/// true/summed = 0.56-0.75), and per-query cost is context-free, so the +/// exact fix is set semantics: a shard's true heights are the unique- +/// query counts of the UNION of its segments' records. Each segment +/// ships a per-circuit membership sketch of its record (the stored +/// 64-bit entry hashes — no rehashing): an EXACT hash list for maps up +/// to [`SKETCH_EXACT_MAX`] uniques, a HyperLogLog register array above. +/// The merge unions sketches instead of summing, feeds the estimated +/// union heights to the same analytic cost/RAM model, and cuts directly +/// at the budget — no overshoot factor, no cold re-price pass. +/// +/// HLL precision: `2^HLL_P` registers → σ ≈ 1.04/√2^P (~1.2% at P=13). +/// Estimates from HLL (never the exact lists) are inflated by +/// [`SKETCH_SAFETY`] (~2σ) so sketch noise errs conservative, and every +/// estimate is clamped to [max single-segment raw, Σ raws]. +const HLL_P: u32 = 13; +const HLL_REGS: usize = 1 << HLL_P; +const SKETCH_EXACT_MAX: usize = 1024; +const SKETCH_SAFETY: f64 = 1.025; + +/// `u64 → f64` without a lossy `as` cast (split into exactly-convertible +/// `u32` halves — the sketch magnitudes sit far below the 2^52 edge). +fn f64_from_u64(n: u64) -> f64 { + let hi = u32::try_from(n >> 32).expect("u64 is 64 bits"); + let lo = u32::try_from(n & 0xFFFF_FFFF).expect("masked to u32 range"); + f64::from(hi) * 4_294_967_296.0 + f64::from(lo) +} + +/// Saturating `f64 → u64` via decimal round-trip (no lossy `as`; runs a +/// handful of times per merge decision). +fn u64_from_f64(x: f64) -> u64 { + format!("{:.0}", x.max(0.0)).parse().unwrap_or(u64::MAX) +} + +/// splitmix64 finalizer: the stored map hashes are table-quality, not +/// avalanche-quality; HLL register selection and rank both need uniform +/// bits, so every hash is remixed on sketch insert (deterministic, so +/// partitions stay identical across runs and machines). +fn remix(mut x: u64) -> u64 { + x = (x ^ (x >> 30)).wrapping_mul(0xbf58476d1ce4e5b9); + x = (x ^ (x >> 27)).wrapping_mul(0x94d049bb133111eb); + x ^ (x >> 31) +} + +/// One query map's membership sketch: exact remixed hashes while small, +/// HLL registers above [`SKETCH_EXACT_MAX`]. +enum SketchSet { + Exact(Vec), + Hll(Box<[u8]>), +} + +impl SketchSet { + fn hll_insert(regs: &mut [u8], h: u64) { + let idx = usize::try_from(h >> (64 - HLL_P)).expect("HLL_P bits"); + let rank = u8::try_from((h << HLL_P | 1 << (HLL_P - 1)).leading_zeros()) + .expect("leading_zeros of u64 is at most 64") + + 1; + if regs[idx] < rank { + regs[idx] = rank; + } + } + + fn hll_estimate(regs: &[u8]) -> f64 { + let m = f64_from_usize(HLL_REGS); + let mut sum = 0.0f64; + let mut zeros = 0usize; + for &r in regs { + sum += 1.0 / f64_from_usize(1usize << r.min(63)); + if r == 0 { + zeros += 1; + } + } + let alpha = 0.7213 / (1.0 + 1.079 / m); + let e = alpha * m * m / sum; + if e <= 2.5 * m && zeros > 0 { + // Small-range correction: linear counting. + m * (m / f64_from_usize(zeros)).ln() + } else { + e + } + } +} + +/// One map's sketch entry: circuit key, measured raw uniques and +/// retained field elements (the record-bytes term scales with them), and +/// the membership set. +struct MapSketch { + /// 0 = function (id = function index), 1 = memory (id = width). + kind: u8, + id: u32, + raw: u64, + elems: u64, + set: SketchSet, +} + +/// A segment record's per-circuit membership sketches (every nonzero +/// query map, constrained or not — unconstrained maps carry no circuit +/// but do carry record bytes). +struct SegSketch { + maps: Vec, +} + +impl SegSketch { + fn of_record(record: &QueryRecord) -> Self { + let mut maps = Vec::new(); + let mut push = |kind: u8, id: u32, m: &aiur::querymap::QueryMap| { + let raw = m.len(); + if raw == 0 { + return; + } + let set = if raw <= SKETCH_EXACT_MAX { + let mut v = Vec::with_capacity(raw); + m.for_each_hash(|h| v.push(remix(h))); + v.sort_unstable(); + v.dedup(); + SketchSet::Exact(v) + } else { + let mut regs = vec![0u8; HLL_REGS].into_boxed_slice(); + m.for_each_hash(|h| SketchSet::hll_insert(&mut regs, remix(h))); + SketchSet::Hll(regs) + }; + maps.push(MapSketch { + kind, + id, + raw: u64::try_from(raw).unwrap_or(u64::MAX), + elems: u64::try_from(m.retained_elems()).unwrap_or(u64::MAX), + set, + }); + }; + for (i, m) in record.function_queries.iter().enumerate() { + push(0, u32::try_from(i).unwrap_or(u32::MAX), m); + } + for (&w, m) in &record.memory_queries { + push(1, u32::try_from(w).unwrap_or(u32::MAX), m); + } + SegSketch { maps } + } + + fn to_bytes(&self) -> Vec { + let mut out = Vec::new(); + out.extend_from_slice( + &u32::try_from(self.maps.len()).unwrap_or(0).to_le_bytes(), + ); + for m in &self.maps { + out.push(m.kind); + out.extend_from_slice(&m.id.to_le_bytes()); + out.extend_from_slice(&m.raw.to_le_bytes()); + out.extend_from_slice(&m.elems.to_le_bytes()); + match &m.set { + SketchSet::Exact(v) => { + out.push(0); + out.extend_from_slice( + &u32::try_from(v.len()).unwrap_or(0).to_le_bytes(), + ); + for h in v { + out.extend_from_slice(&h.to_le_bytes()); + } + }, + SketchSet::Hll(regs) => { + out.push(1); + out.extend_from_slice(regs); + }, + } + } + out + } + + fn from_bytes(b: &[u8]) -> Option { + let mut p = 0usize; + let take = |p: &mut usize, n: usize| -> Option<&[u8]> { + let s = b.get(*p..*p + n)?; + *p += n; + Some(s) + }; + let n = u32::from_le_bytes(take(&mut p, 4)?.try_into().ok()?) as usize; + let mut maps = Vec::with_capacity(n); + for _ in 0..n { + let kind = take(&mut p, 1)?[0]; + let id = u32::from_le_bytes(take(&mut p, 4)?.try_into().ok()?); + let raw = u64::from_le_bytes(take(&mut p, 8)?.try_into().ok()?); + let elems = u64::from_le_bytes(take(&mut p, 8)?.try_into().ok()?); + let set = match take(&mut p, 1)?[0] { + 0 => { + let k = + u32::from_le_bytes(take(&mut p, 4)?.try_into().ok()?) as usize; + let mut v = Vec::with_capacity(k); + for _ in 0..k { + v.push(u64::from_le_bytes(take(&mut p, 8)?.try_into().ok()?)); + } + SketchSet::Exact(v) + }, + 1 => SketchSet::Hll(take(&mut p, HLL_REGS)?.to_vec().into_boxed_slice()), + _ => return None, + }; + maps.push(MapSketch { kind, id, raw, elems, set }); + } + Some(SegSketch { maps }) + } +} + +/// Running union of segment sketches over one candidate shard. +#[derive(Clone)] +enum AccSet { + Exact(std::collections::HashSet), + Hll(Box<[u8]>), +} + +#[derive(Clone)] +struct MapAcc { + raw_sum: u64, + max_raw: u64, + /// Retained field elements per unique entry (fixed per map: key and + /// output strides are per-circuit constants). + elems_per_raw: f64, + set: AccSet, +} + +impl MapAcc { + fn absorb(&mut self, s: &MapSketch) { + self.raw_sum += s.raw; + self.max_raw = self.max_raw.max(s.raw); + match (&mut self.set, &s.set) { + (AccSet::Exact(acc), SketchSet::Exact(v)) => acc.extend(v.iter()), + (AccSet::Hll(regs), SketchSet::Hll(r)) => { + for (a, b) in regs.iter_mut().zip(r.iter()) { + *a = (*a).max(*b); + } + }, + (AccSet::Exact(acc), SketchSet::Hll(r)) => { + let mut regs = r.clone(); + for &h in acc.iter() { + SketchSet::hll_insert(&mut regs, h); + } + self.set = AccSet::Hll(regs); + }, + (AccSet::Hll(regs), SketchSet::Exact(v)) => { + for &h in v { + SketchSet::hll_insert(regs, h); + } + }, + } + } + + /// Estimated unique entries of the union: exact while every + /// contribution stayed exact; HLL (safety-inflated) once any map went + /// probabilistic; always within [max_raw, raw_sum]. + fn estimate(&self) -> u64 { + let est = match &self.set { + AccSet::Exact(s) => u64::try_from(s.len()).unwrap_or(u64::MAX), + AccSet::Hll(regs) => { + u64_from_f64(SketchSet::hll_estimate(regs) * SKETCH_SAFETY) + }, + }; + est.clamp(self.max_raw, self.raw_sum) + } +} + +#[derive(Clone, Default)] +struct UnionAcc { + maps: std::collections::HashMap<(u8, u32), MapAcc>, + /// Segments that arrived without a sketch (worker of an older vintage, + /// or a decode failure): their summed (fft, ram) is added on top of + /// the union model — conservative, never unsound. + unsketched_fft: f64, + unsketched_ram: f64, + n_segments: usize, +} + +impl UnionAcc { + fn absorb(&mut self, seg: &Segment) { + self.n_segments += 1; + match &seg.sketch { + Some(sk) => { + for m in &sk.maps { + let acc = + self.maps.entry((m.kind, m.id)).or_insert_with(|| MapAcc { + raw_sum: 0, + max_raw: 0, + elems_per_raw: if m.raw > 0 { + f64_from_u64(m.elems) / f64_from_u64(m.raw) + } else { + 0.0 + }, + set: match &m.set { + SketchSet::Exact(_) => { + AccSet::Exact(std::collections::HashSet::new()) + }, + SketchSet::Hll(_) => { + AccSet::Hll(vec![0u8; HLL_REGS].into_boxed_slice()) + }, + }, + }); + acc.absorb(m); + } + }, + None => { + self.unsketched_fft += seg.fft; + self.unsketched_ram += seg.ram_gib; + }, + } + } + + /// Model the union: estimated per-map unique heights + retained + /// elements → the same analytic (fft, peak-prove-RAM) pair a single + /// cold record of the union would produce, plus the summed + /// contribution of unsketched segments. + fn model(&self, system: &AiurSystem) -> (f64, f64) { + let ests: Vec<(bool, usize, usize, usize)> = self + .maps + .iter() + .map(|((kind, id), acc)| { + let est = acc.estimate(); + let elems = usize::try_from(u64_from_f64( + f64_from_u64(est) * acc.elems_per_raw, + )) + .unwrap_or(usize::MAX); + (*kind == 0, *id as usize, usize::try_from(est).unwrap_or(usize::MAX), elems) + }) + .collect(); + let (fft, peak) = system.model_from_map_estimates(&ests); + ( + fft + self.unsketched_fft, + f64_from_usize(peak.peak) / GIB + self.unsketched_ram, + ) + } +} /// Ranges a child serves before the parent proactively reaps and /// respawns it. The env decode cache grows monotonically with content @@ -602,9 +921,6 @@ pub fn scan_worker( }; let failed: Mutex> = Mutex::new(Vec::new()); let abort = std::sync::atomic::AtomicBool::new(false); - // Shard member lists for `PRICE`, loaded lazily on first use — most - // children never price. - let mut price_table: Option>> = None; let ctx = ScanCtx { toplevel, fun_idx, @@ -636,56 +952,6 @@ pub fn scan_worker( // A third field (a since-removed narrow-prefix hint) is accepted // and ignored for wire compatibility with parents of that vintage. let _ = it.next(); - if verb == "PRICE" { - // Cold re-price of one merged shard: execute its whole CheckEnv - // claim (the exact claim its prove runs) with a fresh record and - // report the record's measured fft plus the analytic peak prove - // RSS. `lo` is the shard index in the price file. - let Some(k) = lo else { - return Err(format!("worker: malformed command {line:?}")); - }; - if price_table.is_none() { - let path = std::env::var("IX_SCAN_PRICE_FILE") - .map_err(|_e| "worker: PRICE without IX_SCAN_PRICE_FILE")?; - price_table = Some(read_price_file(&path)?); - } - let table = price_table.as_ref().unwrap(); - let members = table - .get(k) - .ok_or_else(|| format!("worker: PRICE {k} out of range"))?; - let addrs: Vec
= members - .iter() - .map(|&b| blocks[b as usize].addr.clone()) - .collect(); - let mut record = QueryRecord::new(toplevel); - let mut io = - IOBuffer::with_backing(EnvFaultSource::new(env.clone())); - let priced = seed_shard_check_env_claim(env, &addrs, &mut io).and_then( - |(_claim, input)| { - execute_ixvm_with_record(toplevel, fun_idx, &input, &mut io, &mut record) - .map(|_| ()) - .map_err(|e| e.to_string()) - }, - ); - match priced { - Ok(()) => { - let fft = record_fft_cost(toplevel, &record); - let ram = match ctx.system { - Some(sys) => { - f64_from_usize(sys.peak_prove_bytes(&record).peak) / GIB - }, - None => f64_from_usize(record_heap_bytes(&record)) / GIB, - }; - writeln!(out, "COST {fft} {ram}").map_err(|e| e.to_string())?; - }, - Err(e) => { - writeln!(out, "PERR {}", hex_encode(e.as_bytes())) - .map_err(|e| e.to_string())?; - }, - } - out.flush().map_err(|e| e.to_string())?; - continue; - } let (Some(lo), Some(hi)) = (lo, hi) else { return Err(format!("worker: malformed command {line:?}")); }; @@ -705,8 +971,23 @@ pub fn scan_worker( cursor += 1; // a skipped block } let end = cursor + s.blocks.len(); - writeln!(out, "SEG {cursor} {end} {} {}", s.fft, s.ram_gib) - .map_err(|e| e.to_string())?; + // Fifth field: the segment's membership sketch (hex), the + // union-pricing input. Sized by the record's nonzero maps + // (small maps ship exact hash lists, big ones fixed HLL + // registers) — hundreds of KB against a multi-second segment. + match &s.sketch { + Some(sk) => writeln!( + out, + "SEG {cursor} {end} {} {} {}", + s.fft, + s.ram_gib, + hex_encode(&sk.to_bytes()) + ), + None => { + writeln!(out, "SEG {cursor} {end} {} {}", s.fft, s.ram_gib) + }, + } + .map_err(|e| e.to_string())?; cursor = end; } for (a, e) in failed.lock().unwrap().drain(..) { @@ -784,60 +1065,6 @@ fn read_order_file(path: &str) -> Result<(Vec, Vec), String> { Ok((blocks, order)) } -/// Serialize merged shards' member block ids for the re-price workers: -/// `[u64 shard count][per shard: u64 len, u32 ids…]`. Members are block -/// ids into the order file's block table, so a worker prices exactly -/// the claim the manifest will carry (holes from skipped blocks -/// included). -fn write_price_file( - path: &std::path::Path, - shards: &[Vec], -) -> Result<(), String> { - let total: usize = shards.iter().map(Vec::len).sum(); - let mut buf: Vec = Vec::with_capacity(8 + shards.len() * 8 + total * 4); - buf.extend_from_slice(&(shards.len() as u64).to_le_bytes()); - for m in shards { - buf.extend_from_slice(&(m.len() as u64).to_le_bytes()); - for &b in m { - buf.extend_from_slice(&b.to_le_bytes()); - } - } - std::fs::write(path, buf).map_err(|e| format!("write {path:?}: {e}")) -} - -fn read_price_file(path: &str) -> Result>, String> { - let buf = - std::fs::read(path).map_err(|e| format!("read price file {path}: {e}"))?; - let take_u64 = |pos: usize| -> Result { - buf - .get(pos..pos + 8) - .and_then(|b| b.try_into().ok()) - .map(u64::from_le_bytes) - .ok_or_else(|| format!("price file {path}: truncated")) - }; - let count = usize::try_from(take_u64(0)?) - .map_err(|_e| "price file: count overflow".to_string())?; - let mut pos = 8; - let mut shards = Vec::with_capacity(count); - for _ in 0..count { - let len = usize::try_from(take_u64(pos)?) - .map_err(|_e| "price file: len overflow".to_string())?; - pos += 8; - let mut members = Vec::with_capacity(len); - for _ in 0..len { - let v = buf - .get(pos..pos + 4) - .and_then(|b| b.try_into().ok()) - .map(u32::from_le_bytes) - .ok_or_else(|| format!("price file {path}: truncated member"))?; - members.push(v); - pos += 4; - } - shards.push(members); - } - Ok(shards) -} - fn hex_encode(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } @@ -898,9 +1125,6 @@ struct ProcPool<'a> { /// Execute-only phase 1: children measure growth and hand dense /// remainders back (`DEFER`) for the fat phase. defer_growth: bool, - /// Shard member lists for the re-price round (`PRICE` verb); exported - /// to children via `IX_SCAN_PRICE_FILE`. - price_file: Option, } struct WorkerHandle { @@ -962,9 +1186,6 @@ impl ProcPool<'_> { cmd .arg("shard-worker") .env("IX_SCAN_ORDER_FILE", &self.order_file); - if let Some(pf) = &self.price_file { - cmd.env("IX_SCAN_PRICE_FILE", pf); - } cmd // Return freed pages to the OS immediately: the record drops at // every segment cut, but mimalloc retains the pages by default, so @@ -1042,10 +1263,18 @@ impl ProcPool<'_> { ) else { return Err(reply); }; + // Optional fifth field: the segment's membership sketch. A + // missing or undecodable sketch degrades that segment to + // conservative summing at the merge, never to an error. + let sketch = it + .next() + .and_then(hex_decode) + .and_then(|b| SegSketch::from_bytes(&b)); reply.segs.push(Segment { blocks: self.order[s..e].to_vec(), fft, ram_gib: ram, + sketch, }); reply.next = e; }, @@ -1081,44 +1310,6 @@ impl ProcPool<'_> { } } -impl ProcPool<'_> { - /// One `PRICE` round-trip: the child executes shard `k`'s whole - /// CheckEnv claim cold and reports `(fft, ram_gib)` from the record — - /// the exact cost its prove pays. `Err` = the child died (over-cap - /// shard) or reported a pricing error. - fn price( - &self, - h: &mut WorkerHandle, - k: usize, - ) -> Result<(f64, f64), String> { - use std::io::Write; - writeln!(h.stdin, "PRICE {k}").map_err(|e| e.to_string())?; - h.stdin.flush().map_err(|e| e.to_string())?; - let line = h.read_line()?; - let mut it = line.split_whitespace(); - match it.next() { - Some("COST") => { - let (Some(fft), Some(ram)) = ( - it.next().and_then(|v| v.parse::().ok()), - it.next().and_then(|v| v.parse::().ok()), - ) else { - return Err(format!("bad COST reply {line:?}")); - }; - Ok((fft, ram)) - }, - Some("PERR") => Err( - it.next() - .and_then(hex_decode) - .map_or_else( - || "pricing error".to_string(), - |m| String::from_utf8_lossy(&m).into_owned(), - ), - ), - _ => Err(format!("bad PRICE reply {line:?}")), - } - } -} - impl WorkerHandle { fn read_line(&mut self) -> Result { use std::io::BufRead; @@ -1497,7 +1688,6 @@ fn run_pool_procs( fail_fast: pool.fail_fast, defer_infeasible: false, defer_growth: false, - price_file: None, }; // Coalesce adjacent deferred ranges: strip remainders abut when a // strip spans chunk edges, and a merged range shares its dependency @@ -1674,8 +1864,7 @@ pub fn execute_env( fail_fast, defer_infeasible: false, defer_growth: true, - price_file: None, - }; + }; run_pool_procs(&pool, bounds, workers, &failed)? }, None => { @@ -1730,7 +1919,6 @@ pub fn scan_shards( workers: usize, fail_fast: bool, defer_infeasible: bool, - reprice: bool, out_path: &str, proc_workers: Option<(&str, &str)>, ) -> Result { @@ -1877,8 +2065,7 @@ pub fn scan_shards( fail_fast, defer_infeasible, defer_growth: false, - price_file: None, - }; + }; run_pool_procs(&pool, bounds, workers, &failed)? }, None => { @@ -1888,207 +2075,55 @@ pub fn scan_shards( }, }; - // Assemble shards by summing adjacent segments, then COLD RE-PRICE - // each merged shard: one execution of its whole CheckEnv claim (the - // exact claim its prove runs) replaces the summed cost. Sums are - // conservative (shared cones derive once in the union; padded heights - // are subadditive) but by a measured ~1.6x, so the merge packs past - // the cut by [`PACK_OVERSHOOT`] and the re-price decides: an over-cut - // shard splits at its ram midpoint and the halves re-price, to a - // bounded depth. Process-pool mode only; the thread pool (tests) - // keeps the pure summed pack at the plain cut. + // Assemble shards by UNION pricing adjacent segments. A candidate + // shard's true cold cost is the cost of the UNION of its segments' + // records — per-query cost is context-free, so shared cone queries + // deduplicate exactly as they will in the prove's single cold record. + // The merge unions the segments' membership sketches, feeds the + // estimated union heights to the same analytic cost/RAM model the cut + // charges, and closes a shard where the modeled union RAM reaches the + // cut — no overshoot pack, no cold re-price pass. Summed costs + // overstated true cost by a measured 1.3-1.8x (cross-segment cone + // double-counting); the union estimate is exact where every map + // stayed under [`SKETCH_EXACT_MAX`] uniques and within ~±2% (erring + // conservative) where HLL registers took over. let pre_merge = segments.len(); - // Opt-in (`ix shard --reprice`, fail-fast mode strings "3"/"4"): the - // cold re-price is prove-validated on Init (+0.77% at a shard packed - // to the cut) but not yet on FLT/Mathlib-class content, so summed - // conservative costs remain the default until each env's re-priced - // manifest passes its heaviest-shard prove protocol. - let pricing = reprice && proc_workers.is_some(); - let pack_target = - if pricing { cut_used_gib * PACK_OVERSHOOT } else { cut_used_gib }; - let mut groups: Vec> = Vec::new(); + let mut packed: Vec<(Vec, f64, f64)> = Vec::new(); { - let mut sums: Vec = Vec::new(); + let mut cur_blocks: Vec = Vec::new(); + let mut acc = UnionAcc::default(); + let mut cur_cost = (0.0f64, 0.0f64); for seg in segments { - match (groups.last_mut(), sums.last_mut()) { - (Some(g), Some(sum)) if *sum + seg.ram_gib < pack_target => { - *sum += seg.ram_gib; - g.push(seg); - }, - _ => { - sums.push(seg.ram_gib); - groups.push(vec![seg]); - }, + let mut trial = acc.clone(); + trial.absorb(&seg); + let (tf, tr) = trial.model(system); + if tr >= cut_used_gib && !cur_blocks.is_empty() { + // Close the running shard; this segment opens the next. + packed.push(( + std::mem::take(&mut cur_blocks), + cur_cost.0, + cur_cost.1, + )); + acc = UnionAcc::default(); + acc.absorb(&seg); + cur_cost = acc.model(system); + } else { + acc = trial; + cur_cost = (tf, tr); } + cur_blocks.extend(&seg.blocks); } - } - // (summed fft, summed ram, priced (fft, ram) once measured) - let group_sum = |g: &Vec| -> (f64, f64) { - g.iter().fold((0.0, 0.0), |(f, r), s| (f + s.fft, r + s.ram_gib)) - }; - let mut priced: Vec> = vec![None; groups.len()]; - if pricing { - let (bin, ixe) = proc_workers.expect("pricing implies proc workers"); - let t0 = std::time::Instant::now(); - // The scan pool (and its order file) are gone; the price pool gets - // fresh copies of both sidecar files. - let order_file = std::env::temp_dir() - .join(format!("ix-price-order-{}.bin", std::process::id())); - write_order_file(&order_file, &blocks, &order)?; - let price_file = std::env::temp_dir() - .join(format!("ix-price-shards-{}.bin", std::process::id())); - let width = REPRICE_WORKERS.min(groups.len()).max(1); - let cap_gib = (pool_gib / f64_from_usize(REPRICE_WORKERS)) - .max(SLICE_FLOOR_GIB); - let price_pool = ProcPool { - bin: bin.to_string(), - ixe: ixe.to_string(), - cut_used_gib, - batch_blocks, - soft_record_gib: f64::INFINITY, - pieces: sched_pieces, - exec_only: false, - cap_bytes: gib_to_bytes_u64(cap_gib), - cleanup_cap_bytes: gib_to_bytes_u64(cap_gib), - cleanup: true, - order_file: order_file.clone(), - capped: systemd_scope_caps_available(), - order: &order, - blocks: &blocks, - fail_fast: false, - defer_infeasible: false, - defer_growth: false, - price_file: Some(price_file.clone()), - }; - // Rounds: price every unpriced group; split over-cut multi-segment - // groups at their summed-ram midpoint and unprice the halves. - for _round in 0..3 { - let todo: Vec = - (0..groups.len()).filter(|&i| priced[i].is_none()).collect(); - if todo.is_empty() { - break; - } - let members: Vec> = todo - .iter() - .map(|&i| { - groups[i].iter().flat_map(|s| s.blocks.iter().copied()).collect() - }) - .collect(); - write_price_file(&price_file, &members)?; - let queue: Mutex> = - Mutex::new((0..todo.len()).collect()); - let results: Mutex>> = - Mutex::new(vec![None; todo.len()]); - std::thread::scope(|sc| { - for slot in 0..width.min(todo.len()) { - let (queue, results, price_pool) = (&queue, &results, &price_pool); - sc.spawn(move || { - let mut worker = match price_pool.spawn(slot) { - Ok(w) => w, - Err(_e) => return, - }; - loop { - let Some(j) = queue.lock().unwrap().pop_front() else { - break; - }; - match price_pool.price(&mut worker, j) { - Ok(cost) => results.lock().unwrap()[j] = Some(cost), - Err(_e) => { - // Death or pricing error: one fresh-worker retry, - // then the group falls back to its summed cost. - worker = match price_pool.spawn(slot) { - Ok(w) => w, - Err(_e) => break, - }; - if let Ok(cost) = price_pool.price(&mut worker, j) { - results.lock().unwrap()[j] = Some(cost); - } - } - } - } - worker.reap(); - }); - } - }); - let results = results.into_inner().unwrap(); - for (pos, &i) in todo.iter().enumerate() { - priced[i] = Some(match results[pos] { - Some(cost) => cost, - None => group_sum(&groups[i]), - }); - } - // Split over-cut multi-segment groups; their halves re-price in - // the next round. - let mut next_groups: Vec> = Vec::new(); - let mut next_priced: Vec> = Vec::new(); - let mut split = 0usize; - for (i, g) in groups.into_iter().enumerate() { - let over = priced[i].is_some_and(|(_f, r)| r >= cut_used_gib); - if over && g.len() > 1 { - let total: f64 = g.iter().map(|s| s.ram_gib).sum(); - let mut acc = 0.0; - let mut cutp = g.len() - 1; - for (k, s) in g.iter().enumerate() { - acc += s.ram_gib; - if acc >= total / 2.0 { - cutp = (k + 1).min(g.len() - 1); - break; - } - } - let mut a = g; - let b = a.split_off(cutp); - split += 1; - next_groups.push(a); - next_priced.push(None); - next_groups.push(b); - next_priced.push(None); - } else { - next_priced.push(priced[i]); - next_groups.push(g); - } - } - groups = next_groups; - priced = next_priced; - if split == 0 { - break; - } - eprintln!("[scan] re-price: {split} over-cut shard(s) split"); + if !cur_blocks.is_empty() { + packed.push((cur_blocks, cur_cost.0, cur_cost.1)); } - let _ = std::fs::remove_file(&order_file); - let _ = std::fs::remove_file(&price_file); - let ratios: Vec = groups - .iter() - .zip(&priced) - .filter_map(|(g, p)| { - p.map(|(_f, r)| { - let (_sf, sr) = group_sum(g); - if sr > 0.0 { r / sr } else { 1.0 } - }) - }) - .collect(); - let (rmin, rmax) = ratios.iter().fold((f64::MAX, 0.0f64), |(lo, hi), &r| { - (lo.min(r), hi.max(r)) - }); - eprintln!( - "[scan] re-price: {} shard(s) cold-priced in {:.0}s \ - (true/summed {:.2}-{:.2})", - groups.len(), - t0.elapsed().as_secs_f64(), - rmin, - rmax - ); } - // Flatten to the manifest's segment shape, carrying the priced (or - // summed-fallback) cost per shard. - let segments: Vec = groups + let segments: Vec = packed .into_iter() - .zip(priced) - .map(|(g, p)| { - let (sf, sr) = group_sum(&g); - let (fft, ram_gib) = p.unwrap_or((sf, sr)); - let blocks: Vec = - g.into_iter().flat_map(|s| s.blocks).collect(); - Segment { blocks, fft, ram_gib } + .map(|(blocks, fft, ram_gib)| Segment { + blocks, + fft, + ram_gib, + sketch: None, }) .collect(); @@ -2315,7 +2350,10 @@ fn scan_range( && hi >= narrow_until { defer_rest = true; - break (hi + k, record_fft_cost(ctx.toplevel, &record), { + break (hi + k, match ctx.system { + Some(sys) => sys.fft_cost_of_record(&record), + None => record_fft_cost(ctx.toplevel, &record), + }, { let rec = f64_from_usize(record_heap_bytes(&record)) / GIB; match ctx.system { @@ -2357,7 +2395,13 @@ fn scan_range( skip_failed = true; break (hi, prev_fft, prev_ram); } - let fft = record_fft_cost(ctx.toplevel, &record); + // Scan-mode fft is the 539-grounded model over the record's raw + // heights — one unit across manifest, whole-env, and per-constant + // figures; execute-only keeps the legacy readout (display only). + let fft = match ctx.system { + Some(sys) => sys.fft_cost_of_record(&record), + None => record_fft_cost(ctx.toplevel, &record), + }; let rec_gib = f64_from_usize(record_heap_bytes(&record)) / GIB; // The cut measure: for the scan, the analytic peak-prove-RSS // prediction from the record's circuit shapes; for execute-only @@ -2434,6 +2478,10 @@ fn scan_range( blocks: chunk[lo..seg_end].to_vec(), fft: seg_fft, ram_gib: seg_ram, + // The record may hold a few rows past the checkpoint (a narrowed + // or skipped batch's partial execution) — extra members only + // raise the union estimate, the safe direction. + sketch: ctx.system.map(|_| SegSketch::of_record(&record)), }); } lo = seg_end + usize::from(skip_failed); @@ -2490,11 +2538,10 @@ extern "C" fn rs_aiur_scan_shards_with_env( let workers = workers.to_string().parse::().unwrap_or(0); // `fail_fast` mode string: "1" abort on the first kernel reject, "0" // record-and-skip, "2" record-and-skip + name deferred dense ranges - // infeasible, "3" as "0" + cold re-price, "4" as "2" + cold re-price. + // infeasible. let mode = fail_fast.to_string(); let fail_fast = mode == "1"; - let defer_infeasible = mode == "2" || mode == "4"; - let reprice = mode == "3" || mode == "4"; + let defer_infeasible = mode == "2"; let (bin, ixe) = (worker_bin.to_string(), ixe_path.to_string()); let proc_workers = (!bin.is_empty() && !ixe.is_empty()) .then_some((bin.as_str(), ixe.as_str())); @@ -2507,7 +2554,6 @@ extern "C" fn rs_aiur_scan_shards_with_env( workers, fail_fast, defer_infeasible, - reprice, &out_path.to_string(), proc_workers, ) { diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index 7c431102a..fd884107c 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -4942,7 +4942,7 @@ fn aiur_fn_25( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; @@ -5100,10 +5100,10 @@ fn aiur_fn_25( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; @@ -6837,7 +6837,7 @@ fn aiur_fn_29( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -6858,7 +6858,7 @@ fn aiur_fn_29( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8839,7 +8839,7 @@ fn aiur_fn_53( 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_723] = { let __args: [G; IN_723] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -9202,7 +9202,7 @@ fn aiur_fn_58( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -9619,7 +9619,7 @@ fn aiur_fn_64( 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; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9650,7 +9650,7 @@ fn aiur_fn_65( 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; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9681,7 +9681,7 @@ fn aiur_fn_66( 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; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9769,7 +9769,7 @@ fn aiur_fn_67( let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -13010,7 +13010,7 @@ fn aiur_fn_107( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_5, __v_7]; record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -13518,7 +13518,7 @@ fn aiur_fn_112( const INPUT_SIZE_113: usize = 1; const IN_113: usize = 1; -const OUT_113: usize = 0; +const OUT_113: usize = 1; fn aiur_fn_113( inp: [G; IN_113], record: &mut QueryRecord, @@ -13540,7 +13540,10 @@ fn aiur_fn_113( let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_113] = []; + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_113] = [__v_13]; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -13549,8 +13552,11 @@ fn aiur_fn_113( 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); }; + let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_113] = []; + let __v_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_113] = [__v_13]; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -14454,7 +14460,7 @@ fn aiur_fn_123( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_29]; record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -14510,7 +14516,7 @@ fn aiur_fn_123( 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_731] = { let __args: [G; IN_731] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; @@ -14622,52 +14628,54 @@ fn aiur_fn_126( 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_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - if (__v_8 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_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_125] = { let __args: [G; IN_125] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - match __v_10.as_canonical_u64() { + let __v_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = G::from_u64(1); - if (__v_11 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_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_126] = [__v_4, __v_5]; + let __ret: [G; OUT_126] = [__v_5, __v_7]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_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("div/mod hint: remainder is not less than the divisor".to_string()) }); + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_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_126] = [__v_4, __v_5]; + let __ret: [G; OUT_126] = [__v_5, __v_7]; record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) @@ -15420,38 +15428,38 @@ fn aiur_fn_142( unconstrained: bool, ) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(214); - let __v_1: G = G::from_u64(246); - let __v_2: G = G::from_u64(42); - let __v_3: G = G::from_u64(151); - let __v_4: G = G::from_u64(121); - let __v_5: G = G::from_u64(16); - let __v_6: G = G::from_u64(143); - let __v_7: G = G::from_u64(159); - let __v_8: G = G::from_u64(182); - let __v_9: G = G::from_u64(182); - let __v_10: G = G::from_u64(107); - let __v_11: G = G::from_u64(49); - let __v_12: G = G::from_u64(204); - let __v_13: G = G::from_u64(148); - let __v_14: G = G::from_u64(195); - let __v_15: G = G::from_u64(216); - let __v_16: G = G::from_u64(76); - let __v_17: G = G::from_u64(167); - let __v_18: G = G::from_u64(45); - let __v_19: G = G::from_u64(139); - let __v_20: G = G::from_u64(234); - let __v_21: G = G::from_u64(24); - let __v_22: G = G::from_u64(94); - let __v_23: G = G::from_u64(19); - let __v_24: G = G::from_u64(19); - let __v_25: G = G::from_u64(124); - let __v_26: G = G::from_u64(80); - let __v_27: G = G::from_u64(199); - let __v_28: G = G::from_u64(239); - let __v_29: G = G::from_u64(132); - let __v_30: G = G::from_u64(201); - let __v_31: G = G::from_u64(105); + let __v_0: G = G::from_u64(94); + let __v_1: G = G::from_u64(215); + let __v_2: G = G::from_u64(142); + let __v_3: G = G::from_u64(224); + let __v_4: G = G::from_u64(129); + let __v_5: G = G::from_u64(225); + let __v_6: G = G::from_u64(11); + let __v_7: G = G::from_u64(192); + let __v_8: G = G::from_u64(153); + let __v_9: G = G::from_u64(154); + let __v_10: G = G::from_u64(55); + let __v_11: G = G::from_u64(42); + let __v_12: G = G::from_u64(94); + let __v_13: G = G::from_u64(84); + let __v_14: G = G::from_u64(172); + let __v_15: G = G::from_u64(211); + let __v_16: G = G::from_u64(55); + let __v_17: G = G::from_u64(61); + let __v_18: G = G::from_u64(133); + let __v_19: G = G::from_u64(212); + let __v_20: G = G::from_u64(30); + let __v_21: G = G::from_u64(155); + let __v_22: G = G::from_u64(227); + let __v_23: G = G::from_u64(250); + let __v_24: G = G::from_u64(117); + let __v_25: G = G::from_u64(253); + let __v_26: G = G::from_u64(222); + let __v_27: G = G::from_u64(50); + let __v_28: G = G::from_u64(219); + let __v_29: G = G::from_u64(45); + let __v_30: G = G::from_u64(101); + let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_142] = [__v_32]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15469,38 +15477,38 @@ fn aiur_fn_143( unconstrained: bool, ) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(253); - let __v_1: G = G::from_u64(189); - let __v_2: G = G::from_u64(95); - let __v_3: G = G::from_u64(239); - let __v_4: G = G::from_u64(64); - let __v_5: G = G::from_u64(20); - let __v_6: G = G::from_u64(156); - let __v_7: G = G::from_u64(133); - let __v_8: G = G::from_u64(51); - let __v_9: G = G::from_u64(60); - let __v_10: G = G::from_u64(111); - let __v_11: G = G::from_u64(60); - let __v_12: G = G::from_u64(206); - let __v_13: G = G::from_u64(187); - let __v_14: G = G::from_u64(75); - let __v_15: G = G::from_u64(231); - let __v_16: G = G::from_u64(65); - let __v_17: G = G::from_u64(39); - let __v_18: G = G::from_u64(13); - let __v_19: G = G::from_u64(32); - let __v_20: G = G::from_u64(102); - let __v_21: G = G::from_u64(51); - let __v_22: G = G::from_u64(108); - let __v_23: G = G::from_u64(178); - let __v_24: G = G::from_u64(238); - let __v_25: G = G::from_u64(248); - let __v_26: G = G::from_u64(118); - let __v_27: G = G::from_u64(35); - let __v_28: G = G::from_u64(116); - let __v_29: G = G::from_u64(75); - let __v_30: G = G::from_u64(114); - let __v_31: G = G::from_u64(176); + let __v_0: G = G::from_u64(97); + let __v_1: G = G::from_u64(15); + let __v_2: G = G::from_u64(229); + let __v_3: G = G::from_u64(164); + let __v_4: G = G::from_u64(245); + let __v_5: G = G::from_u64(160); + let __v_6: G = G::from_u64(63); + let __v_7: G = G::from_u64(100); + let __v_8: G = G::from_u64(246); + let __v_9: G = G::from_u64(14); + let __v_10: G = G::from_u64(245); + let __v_11: G = G::from_u64(160); + let __v_12: G = G::from_u64(105); + let __v_13: G = G::from_u64(241); + let __v_14: G = G::from_u64(100); + let __v_15: G = G::from_u64(7); + let __v_16: G = G::from_u64(88); + let __v_17: G = G::from_u64(224); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(161); + let __v_20: G = G::from_u64(180); + let __v_21: G = G::from_u64(213); + let __v_22: G = G::from_u64(127); + let __v_23: G = G::from_u64(213); + let __v_24: G = G::from_u64(148); + let __v_25: G = G::from_u64(134); + let __v_26: G = G::from_u64(110); + let __v_27: G = G::from_u64(159); + let __v_28: G = G::from_u64(107); + let __v_29: G = G::from_u64(51); + let __v_30: G = G::from_u64(129); + let __v_31: G = G::from_u64(237); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_143] = [__v_32]; record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15518,38 +15526,38 @@ fn aiur_fn_144( unconstrained: bool, ) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(102); - let __v_1: G = G::from_u64(73); - let __v_2: G = G::from_u64(102); - let __v_3: G = G::from_u64(86); - let __v_4: G = G::from_u64(7); - let __v_5: G = G::from_u64(176); - let __v_6: G = G::from_u64(117); - let __v_7: G = G::from_u64(12); - let __v_8: G = G::from_u64(44); - let __v_9: G = G::from_u64(167); - let __v_10: G = G::from_u64(63); - let __v_11: G = G::from_u64(69); - let __v_12: G = G::from_u64(222); - let __v_13: G = G::from_u64(96); - let __v_14: G = G::from_u64(15); - let __v_15: G = G::from_u64(33); - let __v_16: G = G::from_u64(203); - let __v_17: G = G::from_u64(103); - let __v_18: G = G::from_u64(3); - let __v_19: G = G::from_u64(152); - let __v_20: G = G::from_u64(80); - let __v_21: G = G::from_u64(72); - let __v_22: G = G::from_u64(101); - let __v_23: G = G::from_u64(187); - let __v_24: G = G::from_u64(151); - let __v_25: G = G::from_u64(151); - let __v_26: G = G::from_u64(36); - let __v_27: G = G::from_u64(56); - let __v_28: G = G::from_u64(1); - let __v_29: G = G::from_u64(79); - let __v_30: G = G::from_u64(150); - let __v_31: G = G::from_u64(217); + let __v_0: G = G::from_u64(218); + let __v_1: G = G::from_u64(111); + let __v_2: G = G::from_u64(183); + let __v_3: G = G::from_u64(37); + let __v_4: G = G::from_u64(128); + let __v_5: G = G::from_u64(61); + let __v_6: G = G::from_u64(183); + let __v_7: G = G::from_u64(159); + let __v_8: G = G::from_u64(49); + let __v_9: G = G::from_u64(142); + let __v_10: G = G::from_u64(138); + let __v_11: G = G::from_u64(239); + let __v_12: G = G::from_u64(91); + let __v_13: G = G::from_u64(25); + let __v_14: G = G::from_u64(225); + let __v_15: G = G::from_u64(212); + let __v_16: G = G::from_u64(194); + let __v_17: G = G::from_u64(209); + let __v_18: G = G::from_u64(167); + let __v_19: G = G::from_u64(196); + let __v_20: G = G::from_u64(24); + let __v_21: G = G::from_u64(49); + let __v_22: G = G::from_u64(223); + let __v_23: G = G::from_u64(72); + let __v_24: G = G::from_u64(120); + let __v_25: G = G::from_u64(126); + let __v_26: G = G::from_u64(138); + let __v_27: G = G::from_u64(49); + let __v_28: G = G::from_u64(155); + let __v_29: G = G::from_u64(140); + let __v_30: G = G::from_u64(72); + let __v_31: G = G::from_u64(211); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_144] = [__v_32]; record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15567,38 +15575,38 @@ fn aiur_fn_145( unconstrained: bool, ) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(51); - let __v_1: G = G::from_u64(198); - let __v_2: G = G::from_u64(4); - let __v_3: G = G::from_u64(69); - let __v_4: G = G::from_u64(29); - let __v_5: G = G::from_u64(1); - let __v_6: G = G::from_u64(203); - let __v_7: G = G::from_u64(25); - let __v_8: G = G::from_u64(164); - let __v_9: G = G::from_u64(51); - let __v_10: G = G::from_u64(102); - let __v_11: G = G::from_u64(130); - let __v_12: G = G::from_u64(70); - let __v_13: G = G::from_u64(185); - let __v_14: G = G::from_u64(143); - let __v_15: G = G::from_u64(110); - let __v_16: G = G::from_u64(135); - let __v_17: G = G::from_u64(75); - let __v_18: G = G::from_u64(214); - let __v_19: G = G::from_u64(48); - let __v_20: G = G::from_u64(183); - let __v_21: G = G::from_u64(138); - let __v_22: G = G::from_u64(121); - let __v_23: G = G::from_u64(29); - let __v_24: G = G::from_u64(122); - let __v_25: G = G::from_u64(55); - let __v_26: G = G::from_u64(58); - let __v_27: G = G::from_u64(151); - let __v_28: G = G::from_u64(152); - let __v_29: G = G::from_u64(73); - let __v_30: G = G::from_u64(161); - let __v_31: G = G::from_u64(207); + let __v_0: G = G::from_u64(171); + let __v_1: G = G::from_u64(111); + let __v_2: G = G::from_u64(63); + let __v_3: G = G::from_u64(28); + let __v_4: G = G::from_u64(173); + let __v_5: G = G::from_u64(99); + let __v_6: G = G::from_u64(108); + let __v_7: G = G::from_u64(238); + let __v_8: G = G::from_u64(182); + let __v_9: G = G::from_u64(125); + let __v_10: G = G::from_u64(247); + let __v_11: G = G::from_u64(73); + let __v_12: G = G::from_u64(205); + let __v_13: G = G::from_u64(124); + let __v_14: G = G::from_u64(198); + let __v_15: G = G::from_u64(52); + let __v_16: G = G::from_u64(162); + let __v_17: G = G::from_u64(214); + let __v_18: G = G::from_u64(138); + let __v_19: G = G::from_u64(235); + let __v_20: G = G::from_u64(84); + let __v_21: G = G::from_u64(37); + let __v_22: G = G::from_u64(94); + let __v_23: G = G::from_u64(8); + let __v_24: G = G::from_u64(92); + let __v_25: G = G::from_u64(167); + let __v_26: G = G::from_u64(239); + let __v_27: G = G::from_u64(105); + let __v_28: G = G::from_u64(43); + let __v_29: G = G::from_u64(57); + let __v_30: G = G::from_u64(94); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_145] = [__v_32]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15616,38 +15624,38 @@ fn aiur_fn_146( unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(59); - let __v_1: G = G::from_u64(228); - let __v_2: G = G::from_u64(131); - let __v_3: G = G::from_u64(87); - let __v_4: G = G::from_u64(174); - let __v_5: G = G::from_u64(23); - let __v_6: G = G::from_u64(247); - let __v_7: G = G::from_u64(77); - let __v_8: G = G::from_u64(77); - let __v_9: G = G::from_u64(242); - let __v_10: G = G::from_u64(125); - let __v_11: G = G::from_u64(105); - let __v_12: G = G::from_u64(122); - let __v_13: G = G::from_u64(237); - let __v_14: G = G::from_u64(63); - let __v_15: G = G::from_u64(71); - let __v_16: G = G::from_u64(193); - let __v_17: G = G::from_u64(48); - let __v_18: G = G::from_u64(121); - let __v_19: G = G::from_u64(65); - let __v_20: G = G::from_u64(244); - let __v_21: G = G::from_u64(26); - let __v_22: G = G::from_u64(255); - let __v_23: G = G::from_u64(207); - let __v_24: G = G::from_u64(116); - let __v_25: G = G::from_u64(218); - let __v_26: G = G::from_u64(95); - let __v_27: G = G::from_u64(102); - let __v_28: G = G::from_u64(213); - let __v_29: G = G::from_u64(17); - let __v_30: G = G::from_u64(167); - let __v_31: G = G::from_u64(151); + let __v_0: G = G::from_u64(140); + let __v_1: G = G::from_u64(212); + let __v_2: G = G::from_u64(25); + let __v_3: G = G::from_u64(144); + let __v_4: G = G::from_u64(68); + let __v_5: G = G::from_u64(73); + let __v_6: G = G::from_u64(164); + let __v_7: G = G::from_u64(217); + let __v_8: G = G::from_u64(27); + let __v_9: G = G::from_u64(234); + let __v_10: G = G::from_u64(184); + let __v_11: G = G::from_u64(77); + let __v_12: G = G::from_u64(194); + let __v_13: G = G::from_u64(107); + let __v_14: G = G::from_u64(72); + let __v_15: G = G::from_u64(178); + let __v_16: G = G::from_u64(22); + let __v_17: G = G::from_u64(218); + let __v_18: G = G::from_u64(254); + let __v_19: G = G::from_u64(22); + let __v_20: G = G::from_u64(54); + let __v_21: G = G::from_u64(215); + let __v_22: G = G::from_u64(31); + let __v_23: G = G::from_u64(72); + let __v_24: G = G::from_u64(220); + let __v_25: G = G::from_u64(192); + let __v_26: G = G::from_u64(210); + let __v_27: G = G::from_u64(12); + let __v_28: G = G::from_u64(159); + let __v_29: G = G::from_u64(237); + let __v_30: G = G::from_u64(16); + let __v_31: G = G::from_u64(235); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_146] = [__v_32]; record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15665,38 +15673,38 @@ fn aiur_fn_147( unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(81); - let __v_1: G = G::from_u64(121); - let __v_2: G = G::from_u64(99); - let __v_3: G = G::from_u64(139); - let __v_4: G = G::from_u64(130); - let __v_5: G = G::from_u64(204); - let __v_6: G = G::from_u64(131); - let __v_7: G = G::from_u64(55); - let __v_8: G = G::from_u64(145); - let __v_9: G = G::from_u64(74); - let __v_10: G = G::from_u64(123); - let __v_11: G = G::from_u64(202); - let __v_12: G = G::from_u64(173); - let __v_13: G = G::from_u64(133); - let __v_14: G = G::from_u64(140); - let __v_15: G = G::from_u64(133); - let __v_16: G = G::from_u64(136); - let __v_17: G = G::from_u64(136); - let __v_18: G = G::from_u64(68); - let __v_19: G = G::from_u64(233); - let __v_20: G = G::from_u64(162); - let __v_21: G = G::from_u64(146); - let __v_22: G = G::from_u64(67); - let __v_23: G = G::from_u64(12); - let __v_24: G = G::from_u64(172); - let __v_25: G = G::from_u64(81); - let __v_26: G = G::from_u64(229); - let __v_27: G = G::from_u64(234); - let __v_28: G = G::from_u64(220); - let __v_29: G = G::from_u64(65); - let __v_30: G = G::from_u64(161); - let __v_31: G = G::from_u64(175); + let __v_0: G = G::from_u64(79); + let __v_1: G = G::from_u64(201); + let __v_2: G = G::from_u64(21); + let __v_3: G = G::from_u64(136); + let __v_4: G = G::from_u64(208); + let __v_5: G = G::from_u64(176); + let __v_6: G = G::from_u64(78); + let __v_7: G = G::from_u64(233); + let __v_8: G = G::from_u64(235); + let __v_9: G = G::from_u64(34); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(200); + let __v_12: G = G::from_u64(11); + let __v_13: G = G::from_u64(114); + let __v_14: G = G::from_u64(179); + let __v_15: G = G::from_u64(157); + let __v_16: G = G::from_u64(239); + let __v_17: G = G::from_u64(161); + let __v_18: G = G::from_u64(237); + let __v_19: G = G::from_u64(244); + let __v_20: G = G::from_u64(92); + let __v_21: G = G::from_u64(130); + let __v_22: G = G::from_u64(229); + let __v_23: G = G::from_u64(234); + let __v_24: G = G::from_u64(227); + let __v_25: G = G::from_u64(78); + let __v_26: G = G::from_u64(31); + let __v_27: G = G::from_u64(113); + let __v_28: G = G::from_u64(133); + let __v_29: G = G::from_u64(141); + let __v_30: G = G::from_u64(118); + let __v_31: G = G::from_u64(182); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_147] = [__v_32]; record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15714,38 +15722,38 @@ fn aiur_fn_148( unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(137); - let __v_1: G = G::from_u64(222); - let __v_2: G = G::from_u64(202); - let __v_3: G = G::from_u64(134); - let __v_4: G = G::from_u64(221); - let __v_5: G = G::from_u64(143); - let __v_6: G = G::from_u64(0); - let __v_7: G = G::from_u64(102); - let __v_8: G = G::from_u64(165); - let __v_9: G = G::from_u64(6); - let __v_10: G = G::from_u64(79); - let __v_11: G = G::from_u64(219); - let __v_12: G = G::from_u64(25); - let __v_13: G = G::from_u64(162); - let __v_14: G = G::from_u64(198); - let __v_15: G = G::from_u64(137); - let __v_16: G = G::from_u64(122); - let __v_17: G = G::from_u64(58); - let __v_18: G = G::from_u64(152); - let __v_19: G = G::from_u64(103); - let __v_20: G = G::from_u64(202); - let __v_21: G = G::from_u64(173); - let __v_22: G = G::from_u64(192); - let __v_23: G = G::from_u64(79); - let __v_24: G = G::from_u64(119); - let __v_25: G = G::from_u64(141); - let __v_26: G = G::from_u64(92); - let __v_27: G = G::from_u64(92); - let __v_28: G = G::from_u64(208); - let __v_29: G = G::from_u64(34); - let __v_30: G = G::from_u64(83); - let __v_31: G = G::from_u64(98); + let __v_0: G = G::from_u64(131); + let __v_1: G = G::from_u64(194); + let __v_2: G = G::from_u64(112); + let __v_3: G = G::from_u64(56); + let __v_4: G = G::from_u64(142); + let __v_5: G = G::from_u64(64); + let __v_6: G = G::from_u64(74); + let __v_7: G = G::from_u64(45); + let __v_8: G = G::from_u64(204); + let __v_9: G = G::from_u64(153); + let __v_10: G = G::from_u64(36); + let __v_11: G = G::from_u64(242); + let __v_12: G = G::from_u64(72); + let __v_13: G = G::from_u64(39); + let __v_14: G = G::from_u64(130); + let __v_15: G = G::from_u64(217); + let __v_16: G = G::from_u64(222); + let __v_17: G = G::from_u64(191); + let __v_18: G = G::from_u64(113); + let __v_19: G = G::from_u64(102); + let __v_20: G = G::from_u64(243); + let __v_21: G = G::from_u64(210); + let __v_22: G = G::from_u64(224); + let __v_23: G = G::from_u64(118); + let __v_24: G = G::from_u64(58); + let __v_25: G = G::from_u64(120); + let __v_26: G = G::from_u64(40); + let __v_27: G = G::from_u64(23); + let __v_28: G = G::from_u64(43); + let __v_29: G = G::from_u64(140); + let __v_30: G = G::from_u64(19); + let __v_31: G = G::from_u64(30); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_148] = [__v_32]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15763,38 +15771,38 @@ fn aiur_fn_149( unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(129); - let __v_1: G = G::from_u64(138); - let __v_2: G = G::from_u64(187); - let __v_3: G = G::from_u64(51); - let __v_4: G = G::from_u64(17); - let __v_5: G = G::from_u64(80); - let __v_6: G = G::from_u64(64); - let __v_7: G = G::from_u64(13); - let __v_8: G = G::from_u64(16); - let __v_9: G = G::from_u64(179); - let __v_10: G = G::from_u64(79); - let __v_11: G = G::from_u64(174); - let __v_12: G = G::from_u64(77); - let __v_13: G = G::from_u64(251); - let __v_14: G = G::from_u64(148); - let __v_15: G = G::from_u64(38); - let __v_16: G = G::from_u64(116); - let __v_17: G = G::from_u64(28); - let __v_18: G = G::from_u64(70); - let __v_19: G = G::from_u64(7); - let __v_20: G = G::from_u64(186); - let __v_21: G = G::from_u64(238); - let __v_22: G = G::from_u64(216); - let __v_23: G = G::from_u64(217); - let __v_24: G = G::from_u64(98); - let __v_25: G = G::from_u64(113); - let __v_26: G = G::from_u64(186); - let __v_27: G = G::from_u64(22); - let __v_28: G = G::from_u64(89); - let __v_29: G = G::from_u64(5); - let __v_30: G = G::from_u64(142); - let __v_31: G = G::from_u64(248); + let __v_0: G = G::from_u64(100); + let __v_1: G = G::from_u64(225); + let __v_2: G = G::from_u64(130); + let __v_3: G = G::from_u64(206); + let __v_4: G = G::from_u64(243); + let __v_5: G = G::from_u64(60); + let __v_6: G = G::from_u64(183); + let __v_7: G = G::from_u64(23); + let __v_8: G = G::from_u64(183); + let __v_9: G = G::from_u64(136); + let __v_10: G = G::from_u64(64); + let __v_11: G = G::from_u64(77); + let __v_12: G = G::from_u64(49); + let __v_13: G = G::from_u64(186); + let __v_14: G = G::from_u64(210); + let __v_15: G = G::from_u64(16); + let __v_16: G = G::from_u64(61); + let __v_17: G = G::from_u64(26); + let __v_18: G = G::from_u64(251); + let __v_19: G = G::from_u64(118); + let __v_20: G = G::from_u64(219); + let __v_21: G = G::from_u64(84); + let __v_22: G = G::from_u64(71); + let __v_23: G = G::from_u64(186); + let __v_24: G = G::from_u64(52); + let __v_25: G = G::from_u64(50); + let __v_26: G = G::from_u64(216); + let __v_27: G = G::from_u64(63); + let __v_28: G = G::from_u64(114); + let __v_29: G = G::from_u64(203); + let __v_30: G = G::from_u64(155); + let __v_31: G = G::from_u64(244); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_32]; record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15812,38 +15820,38 @@ fn aiur_fn_150( unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(155); - let __v_1: G = G::from_u64(118); - let __v_2: G = G::from_u64(243); - let __v_3: G = G::from_u64(43); - let __v_4: G = G::from_u64(187); - let __v_5: G = G::from_u64(29); - let __v_6: G = G::from_u64(189); - let __v_7: G = G::from_u64(244); - let __v_8: G = G::from_u64(255); - let __v_9: G = G::from_u64(104); - let __v_10: G = G::from_u64(224); - let __v_11: G = G::from_u64(34); - let __v_12: G = G::from_u64(18); - let __v_13: G = G::from_u64(37); - let __v_14: G = G::from_u64(1); - let __v_15: G = G::from_u64(93); - let __v_16: G = G::from_u64(240); - let __v_17: G = G::from_u64(202); - let __v_18: G = G::from_u64(45); - let __v_19: G = G::from_u64(42); - let __v_20: G = G::from_u64(96); - let __v_21: G = G::from_u64(35); - let __v_22: G = G::from_u64(193); - let __v_23: G = G::from_u64(168); - let __v_24: G = G::from_u64(19); - let __v_25: G = G::from_u64(6); - let __v_26: G = G::from_u64(212); - let __v_27: G = G::from_u64(2); - let __v_28: G = G::from_u64(13); - let __v_29: G = G::from_u64(78); - let __v_30: G = G::from_u64(243); - let __v_31: G = G::from_u64(151); + let __v_0: G = G::from_u64(215); + let __v_1: G = G::from_u64(93); + let __v_2: G = G::from_u64(225); + let __v_3: G = G::from_u64(42); + let __v_4: G = G::from_u64(88); + let __v_5: G = G::from_u64(75); + let __v_6: G = G::from_u64(213); + let __v_7: G = G::from_u64(254); + let __v_8: G = G::from_u64(186); + let __v_9: G = G::from_u64(248); + let __v_10: G = G::from_u64(154); + let __v_11: G = G::from_u64(119); + let __v_12: G = G::from_u64(40); + let __v_13: G = G::from_u64(220); + let __v_14: G = G::from_u64(98); + let __v_15: G = G::from_u64(112); + let __v_16: G = G::from_u64(237); + let __v_17: G = G::from_u64(56); + let __v_18: G = G::from_u64(174); + let __v_19: G = G::from_u64(23); + let __v_20: G = G::from_u64(151); + let __v_21: G = G::from_u64(255); + let __v_22: G = G::from_u64(90); + let __v_23: G = G::from_u64(68); + let __v_24: G = G::from_u64(104); + let __v_25: G = G::from_u64(59); + let __v_26: G = G::from_u64(141); + let __v_27: G = G::from_u64(241); + let __v_28: G = G::from_u64(89); + let __v_29: G = G::from_u64(80); + let __v_30: G = G::from_u64(153); + let __v_31: G = G::from_u64(148); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_150] = [__v_32]; record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15861,38 +15869,38 @@ fn aiur_fn_151( unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(151); - let __v_1: G = G::from_u64(227); - let __v_2: G = G::from_u64(37); - let __v_3: G = G::from_u64(169); - let __v_4: G = G::from_u64(106); - let __v_5: G = G::from_u64(106); - let __v_6: G = G::from_u64(24); - let __v_7: G = G::from_u64(39); - let __v_8: G = G::from_u64(25); - let __v_9: G = G::from_u64(78); - let __v_10: G = G::from_u64(235); - let __v_11: G = G::from_u64(125); - let __v_12: G = G::from_u64(42); - let __v_13: G = G::from_u64(160); - let __v_14: G = G::from_u64(217); - let __v_15: G = G::from_u64(25); - let __v_16: G = G::from_u64(33); - let __v_17: G = G::from_u64(7); - let __v_18: G = G::from_u64(58); - let __v_19: G = G::from_u64(239); - let __v_20: G = G::from_u64(156); - let __v_21: G = G::from_u64(45); - let __v_22: G = G::from_u64(51); - let __v_23: G = G::from_u64(60); - let __v_24: G = G::from_u64(36); - let __v_25: G = G::from_u64(97); - let __v_26: G = G::from_u64(62); - let __v_27: G = G::from_u64(154); - let __v_28: G = G::from_u64(201); - let __v_29: G = G::from_u64(86); - let __v_30: G = G::from_u64(237); - let __v_31: G = G::from_u64(41); + let __v_0: G = G::from_u64(12); + let __v_1: G = G::from_u64(103); + let __v_2: G = G::from_u64(136); + let __v_3: G = G::from_u64(181); + let __v_4: G = G::from_u64(141); + let __v_5: G = G::from_u64(149); + let __v_6: G = G::from_u64(104); + let __v_7: G = G::from_u64(204); + let __v_8: G = G::from_u64(17); + let __v_9: G = G::from_u64(138); + let __v_10: G = G::from_u64(155); + let __v_11: G = G::from_u64(10); + let __v_12: G = G::from_u64(134); + let __v_13: G = G::from_u64(30); + let __v_14: G = G::from_u64(135); + let __v_15: G = G::from_u64(39); + let __v_16: G = G::from_u64(50); + let __v_17: G = G::from_u64(219); + let __v_18: G = G::from_u64(184); + let __v_19: G = G::from_u64(69); + let __v_20: G = G::from_u64(54); + let __v_21: G = G::from_u64(71); + let __v_22: G = G::from_u64(234); + let __v_23: G = G::from_u64(157); + let __v_24: G = G::from_u64(96); + let __v_25: G = G::from_u64(19); + let __v_26: G = G::from_u64(81); + let __v_27: G = G::from_u64(82); + let __v_28: G = G::from_u64(68); + let __v_29: G = G::from_u64(230); + let __v_30: G = G::from_u64(14); + let __v_31: G = G::from_u64(56); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_151] = [__v_32]; record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15910,38 +15918,38 @@ fn aiur_fn_152( unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(220); - let __v_1: G = G::from_u64(129); - let __v_2: G = G::from_u64(228); - let __v_3: G = G::from_u64(28); - let __v_4: G = G::from_u64(173); - let __v_5: G = G::from_u64(17); - let __v_6: G = G::from_u64(144); - let __v_7: G = G::from_u64(55); - let __v_8: G = G::from_u64(125); - let __v_9: G = G::from_u64(190); - let __v_10: G = G::from_u64(96); - let __v_11: G = G::from_u64(75); - let __v_12: G = G::from_u64(252); - let __v_13: G = G::from_u64(58); - let __v_14: G = G::from_u64(254); - let __v_15: G = G::from_u64(101); + let __v_0: G = G::from_u64(66); + let __v_1: G = G::from_u64(76); + let __v_2: G = G::from_u64(54); + let __v_3: G = G::from_u64(238); + let __v_4: G = G::from_u64(20); + let __v_5: G = G::from_u64(54); + let __v_6: G = G::from_u64(42); + let __v_7: G = G::from_u64(231); + let __v_8: G = G::from_u64(52); + let __v_9: G = G::from_u64(45); + let __v_10: G = G::from_u64(21); + let __v_11: G = G::from_u64(39); + let __v_12: G = G::from_u64(210); + let __v_13: G = G::from_u64(81); + let __v_14: G = G::from_u64(212); + let __v_15: G = G::from_u64(55); let __v_16: G = G::from_u64(138); - let __v_17: G = G::from_u64(65); - let __v_18: G = G::from_u64(59); - let __v_19: G = G::from_u64(154); - let __v_20: G = G::from_u64(45); - let __v_21: G = G::from_u64(207); - let __v_22: G = G::from_u64(188); - let __v_23: G = G::from_u64(171); - let __v_24: G = G::from_u64(121); - let __v_25: G = G::from_u64(250); - let __v_26: G = G::from_u64(215); - let __v_27: G = G::from_u64(183); - let __v_28: G = G::from_u64(165); - let __v_29: G = G::from_u64(205); - let __v_30: G = G::from_u64(217); - let __v_31: G = G::from_u64(84); + let __v_17: G = G::from_u64(253); + let __v_18: G = G::from_u64(42); + let __v_19: G = G::from_u64(69); + let __v_20: G = G::from_u64(163); + let __v_21: G = G::from_u64(181); + let __v_22: G = G::from_u64(9); + let __v_23: G = G::from_u64(125); + let __v_24: G = G::from_u64(45); + let __v_25: G = G::from_u64(42); + let __v_26: G = G::from_u64(224); + let __v_27: G = G::from_u64(50); + let __v_28: G = G::from_u64(29); + let __v_29: G = G::from_u64(95); + let __v_30: G = G::from_u64(159); + let __v_31: G = G::from_u64(255); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_152] = [__v_32]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15959,38 +15967,38 @@ fn aiur_fn_153( unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(109); - let __v_1: G = G::from_u64(180); - let __v_2: G = G::from_u64(147); - let __v_3: G = G::from_u64(4); - let __v_4: G = G::from_u64(191); - let __v_5: G = G::from_u64(15); - let __v_6: G = G::from_u64(90); - let __v_7: G = G::from_u64(203); - let __v_8: G = G::from_u64(253); - let __v_9: G = G::from_u64(29); - let __v_10: G = G::from_u64(157); - let __v_11: G = G::from_u64(154); - let __v_12: G = G::from_u64(12); - let __v_13: G = G::from_u64(27); - let __v_14: G = G::from_u64(122); - let __v_15: G = G::from_u64(226); - let __v_16: G = G::from_u64(14); - let __v_17: G = G::from_u64(249); - let __v_18: G = G::from_u64(157); - let __v_19: G = G::from_u64(7); - let __v_20: G = G::from_u64(55); - let __v_21: G = G::from_u64(136); - let __v_22: G = G::from_u64(112); - let __v_23: G = G::from_u64(86); - let __v_24: G = G::from_u64(18); - let __v_25: G = G::from_u64(159); - let __v_26: G = G::from_u64(91); - let __v_27: G = G::from_u64(92); - let __v_28: G = G::from_u64(181); - let __v_29: G = G::from_u64(169); - let __v_30: G = G::from_u64(186); - let __v_31: G = G::from_u64(138); + let __v_0: G = G::from_u64(170); + let __v_1: G = G::from_u64(155); + let __v_2: G = G::from_u64(97); + let __v_3: G = G::from_u64(190); + let __v_4: G = G::from_u64(220); + let __v_5: G = G::from_u64(158); + let __v_6: G = G::from_u64(230); + let __v_7: G = G::from_u64(169); + let __v_8: G = G::from_u64(144); + let __v_9: G = G::from_u64(141); + let __v_10: G = G::from_u64(95); + let __v_11: G = G::from_u64(14); + let __v_12: G = G::from_u64(152); + let __v_13: G = G::from_u64(149); + let __v_14: G = G::from_u64(95); + let __v_15: G = G::from_u64(24); + let __v_16: G = G::from_u64(51); + let __v_17: G = G::from_u64(15); + let __v_18: G = G::from_u64(56); + let __v_19: G = G::from_u64(88); + let __v_20: G = G::from_u64(125); + let __v_21: G = G::from_u64(247); + let __v_22: G = G::from_u64(16); + let __v_23: G = G::from_u64(253); + let __v_24: G = G::from_u64(235); + let __v_25: G = G::from_u64(228); + let __v_26: G = G::from_u64(21); + let __v_27: G = G::from_u64(206); + let __v_28: G = G::from_u64(199); + let __v_29: G = G::from_u64(218); + let __v_30: G = G::from_u64(41); + let __v_31: G = G::from_u64(237); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_153] = [__v_32]; record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16008,38 +16016,38 @@ fn aiur_fn_154( unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(163); - let __v_1: G = G::from_u64(74); - let __v_2: G = G::from_u64(178); - let __v_3: G = G::from_u64(218); - let __v_4: G = G::from_u64(186); - let __v_5: G = G::from_u64(52); - let __v_6: G = G::from_u64(131); - let __v_7: G = G::from_u64(158); - let __v_8: G = G::from_u64(133); - let __v_9: G = G::from_u64(31); - let __v_10: G = G::from_u64(163); - let __v_11: G = G::from_u64(103); - let __v_12: G = G::from_u64(81); - let __v_13: G = G::from_u64(36); - let __v_14: G = G::from_u64(86); - let __v_15: G = G::from_u64(111); - let __v_16: G = G::from_u64(159); - let __v_17: G = G::from_u64(77); - let __v_18: G = G::from_u64(205); - let __v_19: G = G::from_u64(229); - let __v_20: G = G::from_u64(151); - let __v_21: G = G::from_u64(52); + let __v_0: G = G::from_u64(253); + let __v_1: G = G::from_u64(134); + let __v_2: G = G::from_u64(37); + let __v_3: G = G::from_u64(213); + let __v_4: G = G::from_u64(22); + let __v_5: G = G::from_u64(96); + let __v_6: G = G::from_u64(81); + let __v_7: G = G::from_u64(3); + let __v_8: G = G::from_u64(191); + let __v_9: G = G::from_u64(142); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(154); + let __v_12: G = G::from_u64(93); + let __v_13: G = G::from_u64(134); + let __v_14: G = G::from_u64(212); + let __v_15: G = G::from_u64(125); + let __v_16: G = G::from_u64(52); + let __v_17: G = G::from_u64(221); + let __v_18: G = G::from_u64(71); + let __v_19: G = G::from_u64(193); + let __v_20: G = G::from_u64(239); + let __v_21: G = G::from_u64(100); let __v_22: G = G::from_u64(158); - let __v_23: G = G::from_u64(205); - let __v_24: G = G::from_u64(84); - let __v_25: G = G::from_u64(174); - let __v_26: G = G::from_u64(50); - let __v_27: G = G::from_u64(248); - let __v_28: G = G::from_u64(66); - let __v_29: G = G::from_u64(78); - let __v_30: G = G::from_u64(68); - let __v_31: G = G::from_u64(184); + let __v_23: G = G::from_u64(61); + let __v_24: G = G::from_u64(236); + let __v_25: G = G::from_u64(15); + let __v_26: G = G::from_u64(166); + let __v_27: G = G::from_u64(151); + let __v_28: G = G::from_u64(187); + let __v_29: G = G::from_u64(253); + let __v_30: G = G::from_u64(158); + let __v_31: G = G::from_u64(65); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_154] = [__v_32]; record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16057,38 +16065,38 @@ fn aiur_fn_155( unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(222); - let __v_1: G = G::from_u64(11); - let __v_2: G = G::from_u64(239); - let __v_3: G = G::from_u64(168); - let __v_4: G = G::from_u64(79); - let __v_5: G = G::from_u64(170); - let __v_6: G = G::from_u64(34); - let __v_7: G = G::from_u64(209); - let __v_8: G = G::from_u64(57); - let __v_9: G = G::from_u64(67); - let __v_10: G = G::from_u64(121); - let __v_11: G = G::from_u64(160); - let __v_12: G = G::from_u64(186); - let __v_13: G = G::from_u64(103); - let __v_14: G = G::from_u64(41); - let __v_15: G = G::from_u64(110); - let __v_16: G = G::from_u64(17); - let __v_17: G = G::from_u64(102); - let __v_18: G = G::from_u64(96); - let __v_19: G = G::from_u64(247); - let __v_20: G = G::from_u64(129); - let __v_21: G = G::from_u64(180); - let __v_22: G = G::from_u64(235); - let __v_23: G = G::from_u64(99); - let __v_24: G = G::from_u64(157); - let __v_25: G = G::from_u64(187); - let __v_26: G = G::from_u64(171); - let __v_27: G = G::from_u64(162); - let __v_28: G = G::from_u64(0); - let __v_29: G = G::from_u64(239); - let __v_30: G = G::from_u64(43); - let __v_31: G = G::from_u64(248); + let __v_0: G = G::from_u64(218); + let __v_1: G = G::from_u64(63); + let __v_2: G = G::from_u64(149); + let __v_3: G = G::from_u64(8); + let __v_4: G = G::from_u64(119); + let __v_5: G = G::from_u64(130); + let __v_6: G = G::from_u64(244); + let __v_7: G = G::from_u64(7); + let __v_8: G = G::from_u64(67); + let __v_9: G = G::from_u64(22); + let __v_10: G = G::from_u64(139); + let __v_11: G = G::from_u64(217); + let __v_12: G = G::from_u64(23); + let __v_13: G = G::from_u64(109); + let __v_14: G = G::from_u64(220); + let __v_15: G = G::from_u64(222); + let __v_16: G = G::from_u64(100); + let __v_17: G = G::from_u64(191); + let __v_18: G = G::from_u64(90); + let __v_19: G = G::from_u64(77); + let __v_20: G = G::from_u64(80); + let __v_21: G = G::from_u64(52); + let __v_22: G = G::from_u64(99); + let __v_23: G = G::from_u64(195); + let __v_24: G = G::from_u64(213); + let __v_25: G = G::from_u64(238); + let __v_26: G = G::from_u64(244); + let __v_27: G = G::from_u64(202); + let __v_28: G = G::from_u64(46); + let __v_29: G = G::from_u64(250); + let __v_30: G = G::from_u64(237); + let __v_31: G = G::from_u64(35); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_155] = [__v_32]; record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16204,38 +16212,38 @@ fn aiur_fn_158( unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(207); - let __v_1: G = G::from_u64(134); - let __v_2: G = G::from_u64(38); - let __v_3: G = G::from_u64(53); - let __v_4: G = G::from_u64(33); - let __v_5: G = G::from_u64(211); - let __v_6: G = G::from_u64(69); - let __v_7: G = G::from_u64(195); - let __v_8: G = G::from_u64(144); - let __v_9: G = G::from_u64(118); - let __v_10: G = G::from_u64(71); - let __v_11: G = G::from_u64(62); - let __v_12: G = G::from_u64(205); - let __v_13: G = G::from_u64(185); - let __v_14: G = G::from_u64(246); - let __v_15: G = G::from_u64(253); - let __v_16: G = G::from_u64(65); - let __v_17: G = G::from_u64(27); - let __v_18: G = G::from_u64(91); - let __v_19: G = G::from_u64(80); - let __v_20: G = G::from_u64(59); - let __v_21: G = G::from_u64(206); - let __v_22: G = G::from_u64(131); - let __v_23: G = G::from_u64(226); - let __v_24: G = G::from_u64(49); - let __v_25: G = G::from_u64(139); - let __v_26: G = G::from_u64(163); - let __v_27: G = G::from_u64(251); - let __v_28: G = G::from_u64(111); - let __v_29: G = G::from_u64(35); - let __v_30: G = G::from_u64(118); - let __v_31: G = G::from_u64(216); + let __v_0: G = G::from_u64(169); + let __v_1: G = G::from_u64(22); + let __v_2: G = G::from_u64(36); + let __v_3: G = G::from_u64(68); + let __v_4: G = G::from_u64(83); + let __v_5: G = G::from_u64(147); + let __v_6: G = G::from_u64(166); + let __v_7: G = G::from_u64(116); + let __v_8: G = G::from_u64(250); + let __v_9: G = G::from_u64(15); + let __v_10: G = G::from_u64(158); + let __v_11: G = G::from_u64(159); + let __v_12: G = G::from_u64(154); + let __v_13: G = G::from_u64(82); + let __v_14: G = G::from_u64(244); + let __v_15: G = G::from_u64(27); + let __v_16: G = G::from_u64(147); + let __v_17: G = G::from_u64(177); + let __v_18: G = G::from_u64(4); + let __v_19: G = G::from_u64(135); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(128); + let __v_22: G = G::from_u64(70); + let __v_23: G = G::from_u64(203); + let __v_24: G = G::from_u64(193); + let __v_25: G = G::from_u64(38); + let __v_26: G = G::from_u64(90); + let __v_27: G = G::from_u64(36); + let __v_28: G = G::from_u64(85); + let __v_29: G = G::from_u64(188); + let __v_30: G = G::from_u64(250); + let __v_31: G = G::from_u64(236); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_158] = [__v_32]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16400,38 +16408,38 @@ fn aiur_fn_162( unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(11); - let __v_1: G = G::from_u64(89); - let __v_2: G = G::from_u64(88); - let __v_3: G = G::from_u64(163); - let __v_4: G = G::from_u64(200); - let __v_5: G = G::from_u64(34); - let __v_6: G = G::from_u64(201); - let __v_7: G = G::from_u64(158); - let __v_8: G = G::from_u64(134); - let __v_9: G = G::from_u64(67); - let __v_10: G = G::from_u64(162); - let __v_11: G = G::from_u64(127); - let __v_12: G = G::from_u64(11); - let __v_13: G = G::from_u64(146); - let __v_14: G = G::from_u64(141); - let __v_15: G = G::from_u64(251); - let __v_16: G = G::from_u64(130); - let __v_17: G = G::from_u64(196); - let __v_18: G = G::from_u64(84); - let __v_19: G = G::from_u64(71); - let __v_20: G = G::from_u64(190); - let __v_21: G = G::from_u64(224); - let __v_22: G = G::from_u64(53); - let __v_23: G = G::from_u64(60); - let __v_24: G = G::from_u64(32); - let __v_25: G = G::from_u64(10); - let __v_26: G = G::from_u64(209); - let __v_27: G = G::from_u64(183); - let __v_28: G = G::from_u64(208); - let __v_29: G = G::from_u64(228); - let __v_30: G = G::from_u64(96); - let __v_31: G = G::from_u64(146); + let __v_0: G = G::from_u64(12); + let __v_1: G = G::from_u64(112); + let __v_2: G = G::from_u64(114); + let __v_3: G = G::from_u64(169); + let __v_4: G = G::from_u64(39); + let __v_5: G = G::from_u64(177); + let __v_6: G = G::from_u64(196); + let __v_7: G = G::from_u64(110); + let __v_8: G = G::from_u64(252); + let __v_9: G = G::from_u64(148); + let __v_10: G = G::from_u64(152); + let __v_11: G = G::from_u64(231); + let __v_12: G = G::from_u64(73); + let __v_13: G = G::from_u64(184); + let __v_14: G = G::from_u64(50); + let __v_15: G = G::from_u64(11); + let __v_16: G = G::from_u64(116); + let __v_17: G = G::from_u64(216); + let __v_18: G = G::from_u64(153); + let __v_19: G = G::from_u64(78); + let __v_20: G = G::from_u64(194); + let __v_21: G = G::from_u64(128); + let __v_22: G = G::from_u64(96); + let __v_23: G = G::from_u64(22); + let __v_24: G = G::from_u64(40); + let __v_25: G = G::from_u64(191); + let __v_26: G = G::from_u64(174); + let __v_27: G = G::from_u64(225); + let __v_28: G = G::from_u64(173); + let __v_29: G = G::from_u64(227); + let __v_30: G = G::from_u64(108); + let __v_31: G = G::from_u64(113); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_162] = [__v_32]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16449,38 +16457,38 @@ fn aiur_fn_163( unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(245); - let __v_1: G = G::from_u64(210); - let __v_2: G = G::from_u64(86); - let __v_3: G = G::from_u64(193); - let __v_4: G = G::from_u64(221); - let __v_5: G = G::from_u64(121); - let __v_6: G = G::from_u64(77); - let __v_7: G = G::from_u64(2); - let __v_8: G = G::from_u64(207); - let __v_9: G = G::from_u64(223); - let __v_10: G = G::from_u64(23); - let __v_11: G = G::from_u64(98); - let __v_12: G = G::from_u64(201); - let __v_13: G = G::from_u64(228); - let __v_14: G = G::from_u64(27); - let __v_15: G = G::from_u64(19); - let __v_16: G = G::from_u64(171); - let __v_17: G = G::from_u64(229); - let __v_18: G = G::from_u64(189); - let __v_19: G = G::from_u64(221); - let __v_20: G = G::from_u64(225); - let __v_21: G = G::from_u64(45); - let __v_22: G = G::from_u64(146); - let __v_23: G = G::from_u64(157); - let __v_24: G = G::from_u64(2); - let __v_25: G = G::from_u64(173); - let __v_26: G = G::from_u64(163); - let __v_27: G = G::from_u64(126); - let __v_28: G = G::from_u64(79); - let __v_29: G = G::from_u64(64); - let __v_30: G = G::from_u64(232); - let __v_31: G = G::from_u64(95); + let __v_0: G = G::from_u64(102); + let __v_1: G = G::from_u64(242); + let __v_2: G = G::from_u64(155); + let __v_3: G = G::from_u64(230); + let __v_4: G = G::from_u64(224); + let __v_5: G = G::from_u64(10); + let __v_6: G = G::from_u64(200); + let __v_7: G = G::from_u64(53); + let __v_8: G = G::from_u64(99); + let __v_9: G = G::from_u64(138); + let __v_10: G = G::from_u64(40); + let __v_11: G = G::from_u64(20); + let __v_12: G = G::from_u64(152); + let __v_13: G = G::from_u64(143); + let __v_14: G = G::from_u64(156); + let __v_15: G = G::from_u64(241); + let __v_16: G = G::from_u64(101); + let __v_17: G = G::from_u64(71); + let __v_18: G = G::from_u64(190); + let __v_19: G = G::from_u64(187); + let __v_20: G = G::from_u64(7); + let __v_21: G = G::from_u64(99); + let __v_22: G = G::from_u64(82); + let __v_23: G = G::from_u64(124); + let __v_24: G = G::from_u64(17); + let __v_25: G = G::from_u64(155); + let __v_26: G = G::from_u64(202); + let __v_27: G = G::from_u64(81); + let __v_28: G = G::from_u64(215); + let __v_29: G = G::from_u64(176); + let __v_30: G = G::from_u64(189); + let __v_31: G = G::from_u64(213); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_163] = [__v_32]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16498,38 +16506,38 @@ fn aiur_fn_164( unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(56); - let __v_1: G = G::from_u64(151); - let __v_2: G = G::from_u64(21); - let __v_3: G = G::from_u64(249); - let __v_4: G = G::from_u64(30); - let __v_5: G = G::from_u64(102); - let __v_6: G = G::from_u64(104); - let __v_7: G = G::from_u64(61); - let __v_8: G = G::from_u64(199); - let __v_9: G = G::from_u64(16); - let __v_10: G = G::from_u64(140); - let __v_11: G = G::from_u64(205); - let __v_12: G = G::from_u64(133); - let __v_13: G = G::from_u64(62); - let __v_14: G = G::from_u64(252); - let __v_15: G = G::from_u64(233); - let __v_16: G = G::from_u64(41); - let __v_17: G = G::from_u64(73); - let __v_18: G = G::from_u64(81); - let __v_19: G = G::from_u64(47); - let __v_20: G = G::from_u64(166); - let __v_21: G = G::from_u64(89); - let __v_22: G = G::from_u64(173); - let __v_23: G = G::from_u64(60); - let __v_24: G = G::from_u64(25); - let __v_25: G = G::from_u64(2); - let __v_26: G = G::from_u64(231); - let __v_27: G = G::from_u64(84); - let __v_28: G = G::from_u64(105); - let __v_29: G = G::from_u64(41); - let __v_30: G = G::from_u64(25); - let __v_31: G = G::from_u64(205); + let __v_0: G = G::from_u64(163); + let __v_1: G = G::from_u64(67); + let __v_2: G = G::from_u64(166); + let __v_3: G = G::from_u64(81); + let __v_4: G = G::from_u64(191); + let __v_5: G = G::from_u64(244); + let __v_6: G = G::from_u64(8); + let __v_7: G = G::from_u64(195); + let __v_8: G = G::from_u64(162); + let __v_9: G = G::from_u64(159); + let __v_10: G = G::from_u64(242); + let __v_11: G = G::from_u64(123); + let __v_12: G = G::from_u64(43); + let __v_13: G = G::from_u64(98); + let __v_14: G = G::from_u64(227); + let __v_15: G = G::from_u64(75); + let __v_16: G = G::from_u64(84); + let __v_17: G = G::from_u64(178); + let __v_18: G = G::from_u64(171); + let __v_19: G = G::from_u64(56); + let __v_20: G = G::from_u64(28); + let __v_21: G = G::from_u64(246); + let __v_22: G = G::from_u64(243); + let __v_23: G = G::from_u64(173); + let __v_24: G = G::from_u64(135); + let __v_25: G = G::from_u64(197); + let __v_26: G = G::from_u64(64); + let __v_27: G = G::from_u64(201); + let __v_28: G = G::from_u64(119); + let __v_29: G = G::from_u64(220); + let __v_30: G = G::from_u64(60); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_164] = [__v_32]; record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16893,7 +16901,7 @@ fn aiur_fn_170( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __v_18: G = { let __a_val = __v_16.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 }; @@ -16910,9 +16918,9 @@ fn aiur_fn_170( }, _ => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -16958,7 +16966,7 @@ fn aiur_fn_171( ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -16975,7 +16983,7 @@ fn aiur_fn_171( }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -17039,7 +17047,7 @@ fn aiur_fn_172( ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17056,7 +17064,7 @@ fn aiur_fn_172( }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -17246,38 +17254,38 @@ fn aiur_fn_175( unconstrained: bool, ) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(119); - let __v_1: G = G::from_u64(160); - let __v_2: G = G::from_u64(37); - let __v_3: G = G::from_u64(193); - let __v_4: G = G::from_u64(159); - let __v_5: G = G::from_u64(139); - let __v_6: G = G::from_u64(225); - let __v_7: G = G::from_u64(49); - let __v_8: G = G::from_u64(251); - let __v_9: G = G::from_u64(157); - let __v_10: G = G::from_u64(91); - let __v_11: G = G::from_u64(11); - let __v_12: G = G::from_u64(236); - let __v_13: G = G::from_u64(73); - let __v_14: G = G::from_u64(72); - let __v_15: G = G::from_u64(23); - let __v_16: G = G::from_u64(162); - let __v_17: G = G::from_u64(101); - let __v_18: G = G::from_u64(56); - let __v_19: G = G::from_u64(185); - let __v_20: G = G::from_u64(165); - let __v_21: G = G::from_u64(80); - let __v_22: G = G::from_u64(171); - let __v_23: G = G::from_u64(187); - let __v_24: G = G::from_u64(206); - let __v_25: G = G::from_u64(200); - let __v_26: G = G::from_u64(9); - let __v_27: G = G::from_u64(159); - let __v_28: G = G::from_u64(174); - let __v_29: G = G::from_u64(157); - let __v_30: G = G::from_u64(228); - let __v_31: G = G::from_u64(228); + let __v_0: G = G::from_u64(152); + let __v_1: G = G::from_u64(107); + let __v_2: G = G::from_u64(156); + let __v_3: G = G::from_u64(115); + let __v_4: G = G::from_u64(108); + let __v_5: G = G::from_u64(185); + let __v_6: G = G::from_u64(48); + let __v_7: G = G::from_u64(200); + let __v_8: G = G::from_u64(28); + let __v_9: G = G::from_u64(174); + let __v_10: G = G::from_u64(105); + let __v_11: G = G::from_u64(126); + let __v_12: G = G::from_u64(196); + let __v_13: G = G::from_u64(150); + let __v_14: G = G::from_u64(128); + let __v_15: G = G::from_u64(75); + let __v_16: G = G::from_u64(110); + let __v_17: G = G::from_u64(68); + let __v_18: G = G::from_u64(21); + let __v_19: G = G::from_u64(161); + let __v_20: G = G::from_u64(120); + let __v_21: G = G::from_u64(228); + let __v_22: G = G::from_u64(240); + let __v_23: G = G::from_u64(2); + let __v_24: G = G::from_u64(47); + let __v_25: G = G::from_u64(176); + let __v_26: G = G::from_u64(88); + let __v_27: G = G::from_u64(245); + let __v_28: G = G::from_u64(3); + let __v_29: G = G::from_u64(74); + let __v_30: G = G::from_u64(183); + let __v_31: G = G::from_u64(191); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_175] = [__v_32]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -17295,38 +17303,38 @@ fn aiur_fn_176( unconstrained: bool, ) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(144); - let __v_1: G = G::from_u64(202); - let __v_2: G = G::from_u64(129); - let __v_3: G = G::from_u64(48); - let __v_4: G = G::from_u64(115); - let __v_5: G = G::from_u64(92); - let __v_6: G = G::from_u64(141); - let __v_7: G = G::from_u64(154); - let __v_8: G = G::from_u64(52); - let __v_9: G = G::from_u64(0); - let __v_10: G = G::from_u64(90); - let __v_11: G = G::from_u64(137); - let __v_12: G = G::from_u64(67); - let __v_13: G = G::from_u64(181); - let __v_14: G = G::from_u64(159); - let __v_15: G = G::from_u64(225); - let __v_16: G = G::from_u64(223); - let __v_17: G = G::from_u64(24); - let __v_18: G = G::from_u64(46); - let __v_19: G = G::from_u64(8); - let __v_20: G = G::from_u64(169); - let __v_21: G = G::from_u64(242); - let __v_22: G = G::from_u64(191); - let __v_23: G = G::from_u64(199); - let __v_24: G = G::from_u64(220); - let __v_25: G = G::from_u64(131); - let __v_26: G = G::from_u64(35); - let __v_27: G = G::from_u64(34); - let __v_28: G = G::from_u64(150); - let __v_29: G = G::from_u64(89); - let __v_30: G = G::from_u64(165); - let __v_31: G = G::from_u64(116); + let __v_0: G = G::from_u64(218); + let __v_1: G = G::from_u64(8); + let __v_2: G = G::from_u64(47); + let __v_3: G = G::from_u64(21); + let __v_4: G = G::from_u64(125); + let __v_5: G = G::from_u64(42); + let __v_6: G = G::from_u64(123); + let __v_7: G = G::from_u64(134); + let __v_8: G = G::from_u64(235); + let __v_9: G = G::from_u64(34); + let __v_10: G = G::from_u64(107); + let __v_11: G = G::from_u64(24); + let __v_12: G = G::from_u64(129); + let __v_13: G = G::from_u64(191); + let __v_14: G = G::from_u64(172); + let __v_15: G = G::from_u64(208); + let __v_16: G = G::from_u64(217); + let __v_17: G = G::from_u64(221); + let __v_18: G = G::from_u64(27); + let __v_19: G = G::from_u64(225); + let __v_20: G = G::from_u64(122); + let __v_21: G = G::from_u64(39); + let __v_22: G = G::from_u64(225); + let __v_23: G = G::from_u64(63); + let __v_24: G = G::from_u64(163); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(192); + let __v_27: G = G::from_u64(21); + let __v_28: G = G::from_u64(196); + let __v_29: G = G::from_u64(255); + let __v_30: G = G::from_u64(191); + let __v_31: G = G::from_u64(133); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_32]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -17344,38 +17352,38 @@ fn aiur_fn_177( unconstrained: bool, ) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(105); - let __v_1: G = G::from_u64(141); - let __v_2: G = G::from_u64(213); - let __v_3: G = G::from_u64(147); - let __v_4: G = G::from_u64(171); - let __v_5: G = G::from_u64(251); - let __v_6: G = G::from_u64(99); - let __v_7: G = G::from_u64(219); - let __v_8: G = G::from_u64(54); - let __v_9: G = G::from_u64(42); - let __v_10: G = G::from_u64(174); - let __v_11: G = G::from_u64(245); - let __v_12: G = G::from_u64(126); - let __v_13: G = G::from_u64(112); - let __v_14: G = G::from_u64(167); - let __v_15: G = G::from_u64(147); - let __v_16: G = G::from_u64(4); - let __v_17: G = G::from_u64(79); - let __v_18: G = G::from_u64(182); - let __v_19: G = G::from_u64(87); - let __v_20: G = G::from_u64(37); - let __v_21: G = G::from_u64(114); - let __v_22: G = G::from_u64(145); - let __v_23: G = G::from_u64(238); - let __v_24: G = G::from_u64(44); - let __v_25: G = G::from_u64(62); - let __v_26: G = G::from_u64(153); - let __v_27: G = G::from_u64(124); - let __v_28: G = G::from_u64(170); - let __v_29: G = G::from_u64(66); - let __v_30: G = G::from_u64(62); - let __v_31: G = G::from_u64(174); + let __v_0: G = G::from_u64(234); + let __v_1: G = G::from_u64(253); + let __v_2: G = G::from_u64(27); + let __v_3: G = G::from_u64(47); + let __v_4: G = G::from_u64(107); + let __v_5: G = G::from_u64(87); + let __v_6: G = G::from_u64(26); + let __v_7: G = G::from_u64(191); + let __v_8: G = G::from_u64(118); + let __v_9: G = G::from_u64(174); + let __v_10: G = G::from_u64(150); + let __v_11: G = G::from_u64(234); + let __v_12: G = G::from_u64(249); + let __v_13: G = G::from_u64(196); + let __v_14: G = G::from_u64(133); + let __v_15: G = G::from_u64(42); + let __v_16: G = G::from_u64(164); + let __v_17: G = G::from_u64(82); + let __v_18: G = G::from_u64(13); + let __v_19: G = G::from_u64(6); + let __v_20: G = G::from_u64(223); + let __v_21: G = G::from_u64(83); + let __v_22: G = G::from_u64(66); + let __v_23: G = G::from_u64(145); + let __v_24: G = G::from_u64(89); + let __v_25: G = G::from_u64(10); + let __v_26: G = G::from_u64(113); + let __v_27: G = G::from_u64(162); + let __v_28: G = G::from_u64(30); + let __v_29: G = G::from_u64(111); + let __v_30: G = G::from_u64(11); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_177] = [__v_32]; record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -17393,38 +17401,38 @@ fn aiur_fn_178( unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(159); - let __v_1: G = G::from_u64(216); - let __v_2: G = G::from_u64(231); - let __v_3: G = G::from_u64(69); - let __v_4: G = G::from_u64(154); - let __v_5: G = G::from_u64(29); - let __v_6: G = G::from_u64(45); - let __v_7: G = G::from_u64(238); - let __v_8: G = G::from_u64(240); - let __v_9: G = G::from_u64(10); - let __v_10: G = G::from_u64(73); - let __v_11: G = G::from_u64(146); - let __v_12: G = G::from_u64(165); - let __v_13: G = G::from_u64(4); - let __v_14: G = G::from_u64(25); - let __v_15: G = G::from_u64(186); - let __v_16: G = G::from_u64(198); - let __v_17: G = G::from_u64(108); - let __v_18: G = G::from_u64(3); - let __v_19: G = G::from_u64(8); - let __v_20: G = G::from_u64(43); - let __v_21: G = G::from_u64(88); - let __v_22: G = G::from_u64(173); - let __v_23: G = G::from_u64(224); - let __v_24: G = G::from_u64(116); - let __v_25: G = G::from_u64(34); - let __v_26: G = G::from_u64(137); - let __v_27: G = G::from_u64(111); - let __v_28: G = G::from_u64(19); - let __v_29: G = G::from_u64(3); - let __v_30: G = G::from_u64(61); - let __v_31: G = G::from_u64(116); + let __v_0: G = G::from_u64(182); + let __v_1: G = G::from_u64(104); + let __v_2: G = G::from_u64(219); + let __v_3: G = G::from_u64(125); + let __v_4: G = G::from_u64(18); + let __v_5: G = G::from_u64(202); + let __v_6: G = G::from_u64(187); + let __v_7: G = G::from_u64(77); + let __v_8: G = G::from_u64(127); + let __v_9: G = G::from_u64(226); + let __v_10: G = G::from_u64(225); + let __v_11: G = G::from_u64(175); + let __v_12: G = G::from_u64(37); + let __v_13: G = G::from_u64(152); + let __v_14: G = G::from_u64(75); + let __v_15: G = G::from_u64(170); + let __v_16: G = G::from_u64(40); + let __v_17: G = G::from_u64(187); + let __v_18: G = G::from_u64(40); + let __v_19: G = G::from_u64(82); + let __v_20: G = G::from_u64(169); + let __v_21: G = G::from_u64(130); + let __v_22: G = G::from_u64(218); + let __v_23: G = G::from_u64(141); + let __v_24: G = G::from_u64(84); + let __v_25: G = G::from_u64(148); + let __v_26: G = G::from_u64(43); + let __v_27: G = G::from_u64(179); + let __v_28: G = G::from_u64(68); + let __v_29: G = G::from_u64(114); + let __v_30: G = G::from_u64(108); + let __v_31: G = G::from_u64(207); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_178] = [__v_32]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -17739,7 +17747,7 @@ fn aiur_fn_184( ) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17756,13 +17764,13 @@ fn aiur_fn_184( }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -17830,7 +17838,7 @@ fn aiur_fn_185( ) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17847,7 +17855,7 @@ fn aiur_fn_185( }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -17875,7 +17883,7 @@ fn aiur_fn_185( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17892,7 +17900,7 @@ fn aiur_fn_185( }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -17920,7 +17928,7 @@ fn aiur_fn_185( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -17937,13 +17945,13 @@ fn aiur_fn_185( }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); @@ -18024,7 +18032,7 @@ fn aiur_fn_186( let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -18032,10 +18040,10 @@ fn aiur_fn_186( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_186] = [__v_12, __v_14, __v_16]; record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18110,7 +18118,7 @@ fn aiur_fn_187( let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -18126,13 +18134,13 @@ fn aiur_fn_187( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -18223,7 +18231,7 @@ fn aiur_fn_188( 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_354] = { let __args: [G; IN_354] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -18304,7 +18312,7 @@ fn aiur_fn_189( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -18324,38 +18332,38 @@ fn aiur_fn_190( unconstrained: bool, ) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(222); - let __v_1: G = G::from_u64(244); - let __v_2: G = G::from_u64(67); - let __v_3: G = G::from_u64(61); - let __v_4: G = G::from_u64(149); - let __v_5: G = G::from_u64(71); - let __v_6: G = G::from_u64(181); - let __v_7: G = G::from_u64(49); - let __v_8: G = G::from_u64(117); - let __v_9: G = G::from_u64(226); - let __v_10: G = G::from_u64(74); - let __v_11: G = G::from_u64(58); - let __v_12: G = G::from_u64(193); - let __v_13: G = G::from_u64(130); - let __v_14: G = G::from_u64(200); - let __v_15: G = G::from_u64(139); - let __v_16: G = G::from_u64(7); - let __v_17: G = G::from_u64(42); - let __v_18: G = G::from_u64(240); - let __v_19: G = G::from_u64(212); - let __v_20: G = G::from_u64(173); - let __v_21: G = G::from_u64(51); - let __v_22: G = G::from_u64(253); - let __v_23: G = G::from_u64(4); - let __v_24: G = G::from_u64(236); - let __v_25: G = G::from_u64(76); - let __v_26: G = G::from_u64(242); - let __v_27: G = G::from_u64(186); - let __v_28: G = G::from_u64(61); - let __v_29: G = G::from_u64(149); - let __v_30: G = G::from_u64(234); - let __v_31: G = G::from_u64(147); + let __v_0: G = G::from_u64(106); + let __v_1: G = G::from_u64(20); + let __v_2: G = G::from_u64(45); + let __v_3: G = G::from_u64(145); + let __v_4: G = G::from_u64(232); + let __v_5: G = G::from_u64(119); + let __v_6: G = G::from_u64(149); + let __v_7: G = G::from_u64(158); + let __v_8: G = G::from_u64(20); + let __v_9: G = G::from_u64(25); + let __v_10: G = G::from_u64(195); + let __v_11: G = G::from_u64(69); + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(138); + let __v_14: G = G::from_u64(121); + let __v_15: G = G::from_u64(163); + let __v_16: G = G::from_u64(233); + let __v_17: G = G::from_u64(88); + let __v_18: G = G::from_u64(24); + let __v_19: G = G::from_u64(87); + let __v_20: G = G::from_u64(122); + let __v_21: G = G::from_u64(253); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(141); + let __v_24: G = G::from_u64(40); + let __v_25: G = G::from_u64(127); + let __v_26: G = G::from_u64(79); + let __v_27: G = G::from_u64(136); + let __v_28: G = G::from_u64(21); + let __v_29: G = G::from_u64(33); + let __v_30: G = G::from_u64(221); + let __v_31: G = G::from_u64(233); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_190] = [__v_32]; record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18373,38 +18381,38 @@ fn aiur_fn_191( unconstrained: bool, ) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(89); - let __v_1: G = G::from_u64(79); - let __v_2: G = G::from_u64(177); - let __v_3: G = G::from_u64(238); - let __v_4: G = G::from_u64(222); - let __v_5: G = G::from_u64(199); - let __v_6: G = G::from_u64(201); - let __v_7: G = G::from_u64(57); - let __v_8: G = G::from_u64(204); - let __v_9: G = G::from_u64(135); - let __v_10: G = G::from_u64(43); - let __v_11: G = G::from_u64(108); - let __v_12: G = G::from_u64(4); - let __v_13: G = G::from_u64(204); - let __v_14: G = G::from_u64(59); - let __v_15: G = G::from_u64(62); - let __v_16: G = G::from_u64(10); - let __v_17: G = G::from_u64(151); - let __v_18: G = G::from_u64(100); - let __v_19: G = G::from_u64(250); - let __v_20: G = G::from_u64(190); - let __v_21: G = G::from_u64(195); - let __v_22: G = G::from_u64(230); - let __v_23: G = G::from_u64(2); - let __v_24: G = G::from_u64(173); - let __v_25: G = G::from_u64(146); - let __v_26: G = G::from_u64(20); - let __v_27: G = G::from_u64(208); - let __v_28: G = G::from_u64(230); - let __v_29: G = G::from_u64(55); - let __v_30: G = G::from_u64(211); - let __v_31: G = G::from_u64(15); + let __v_0: G = G::from_u64(56); + let __v_1: G = G::from_u64(3); + let __v_2: G = G::from_u64(173); + let __v_3: G = G::from_u64(194); + let __v_4: G = G::from_u64(29); + let __v_5: G = G::from_u64(137); + let __v_6: G = G::from_u64(150); + let __v_7: G = G::from_u64(147); + let __v_8: G = G::from_u64(161); + let __v_9: G = G::from_u64(73); + let __v_10: G = G::from_u64(29); + let __v_11: G = G::from_u64(176); + let __v_12: G = G::from_u64(84); + let __v_13: G = G::from_u64(16); + let __v_14: G = G::from_u64(75); + let __v_15: G = G::from_u64(32); + let __v_16: G = G::from_u64(189); + let __v_17: G = G::from_u64(64); + let __v_18: G = G::from_u64(252); + let __v_19: G = G::from_u64(12); + let __v_20: G = G::from_u64(161); + let __v_21: G = G::from_u64(246); + let __v_22: G = G::from_u64(180); + let __v_23: G = G::from_u64(55); + let __v_24: G = G::from_u64(75); + let __v_25: G = G::from_u64(123); + let __v_26: G = G::from_u64(21); + let __v_27: G = G::from_u64(139); + let __v_28: G = G::from_u64(66); + let __v_29: G = G::from_u64(82); + let __v_30: G = G::from_u64(179); + let __v_31: G = G::from_u64(139); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_191] = [__v_32]; record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18422,38 +18430,38 @@ fn aiur_fn_192( unconstrained: bool, ) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(150); - let __v_1: G = G::from_u64(113); - let __v_2: G = G::from_u64(253); - let __v_3: G = G::from_u64(79); - let __v_4: G = G::from_u64(207); - let __v_5: G = G::from_u64(188); - let __v_6: G = G::from_u64(6); - let __v_7: G = G::from_u64(28); - let __v_8: G = G::from_u64(147); - let __v_9: G = G::from_u64(194); - let __v_10: G = G::from_u64(130); - let __v_11: G = G::from_u64(72); - let __v_12: G = G::from_u64(100); - let __v_13: G = G::from_u64(207); - let __v_14: G = G::from_u64(3); - let __v_15: G = G::from_u64(18); - let __v_16: G = G::from_u64(79); - let __v_17: G = G::from_u64(254); - let __v_18: G = G::from_u64(231); - let __v_19: G = G::from_u64(204); - let __v_20: G = G::from_u64(34); - let __v_21: G = G::from_u64(48); - let __v_22: G = G::from_u64(141); - let __v_23: G = G::from_u64(225); - let __v_24: G = G::from_u64(42); - let __v_25: G = G::from_u64(124); - let __v_26: G = G::from_u64(130); - let __v_27: G = G::from_u64(100); - let __v_28: G = G::from_u64(115); - let __v_29: G = G::from_u64(228); - let __v_30: G = G::from_u64(153); - let __v_31: G = G::from_u64(6); + let __v_0: G = G::from_u64(142); + let __v_1: G = G::from_u64(158); + let __v_2: G = G::from_u64(106); + let __v_3: G = G::from_u64(242); + let __v_4: G = G::from_u64(214); + let __v_5: G = G::from_u64(90); + let __v_6: G = G::from_u64(23); + let __v_7: G = G::from_u64(9); + let __v_8: G = G::from_u64(74); + let __v_9: G = G::from_u64(135); + let __v_10: G = G::from_u64(80); + let __v_11: G = G::from_u64(15); + let __v_12: G = G::from_u64(132); + let __v_13: G = G::from_u64(247); + let __v_14: G = G::from_u64(178); + let __v_15: G = G::from_u64(109); + let __v_16: G = G::from_u64(130); + let __v_17: G = G::from_u64(237); + let __v_18: G = G::from_u64(202); + let __v_19: G = G::from_u64(208); + let __v_20: G = G::from_u64(221); + let __v_21: G = G::from_u64(105); + let __v_22: G = G::from_u64(153); + let __v_23: G = G::from_u64(121); + let __v_24: G = G::from_u64(74); + let __v_25: G = G::from_u64(139); + let __v_26: G = G::from_u64(70); + let __v_27: G = G::from_u64(236); + let __v_28: G = G::from_u64(181); + let __v_29: G = G::from_u64(84); + let __v_30: G = G::from_u64(36); + let __v_31: G = G::from_u64(45); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_192] = [__v_32]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18471,38 +18479,38 @@ fn aiur_fn_193( unconstrained: bool, ) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(26); - let __v_1: G = G::from_u64(76); - let __v_2: G = G::from_u64(102); - let __v_3: G = G::from_u64(247); - let __v_4: G = G::from_u64(103); - let __v_5: G = G::from_u64(96); + let __v_0: G = G::from_u64(96); + let __v_1: G = G::from_u64(75); + let __v_2: G = G::from_u64(35); + let __v_3: G = G::from_u64(205); + let __v_4: G = G::from_u64(15); + let __v_5: G = G::from_u64(172); let __v_6: G = G::from_u64(245); - let __v_7: G = G::from_u64(239); - let __v_8: G = G::from_u64(56); + let __v_7: G = G::from_u64(179); + let __v_8: G = G::from_u64(229); let __v_9: G = G::from_u64(109); - let __v_10: G = G::from_u64(224); - let __v_11: G = G::from_u64(137); - let __v_12: G = G::from_u64(104); - let __v_13: G = G::from_u64(42); - let __v_14: G = G::from_u64(85); - let __v_15: G = G::from_u64(183); - let __v_16: G = G::from_u64(82); - let __v_17: G = G::from_u64(19); - let __v_18: G = G::from_u64(30); - let __v_19: G = G::from_u64(20); - let __v_20: G = G::from_u64(160); - let __v_21: G = G::from_u64(133); - let __v_22: G = G::from_u64(87); - let __v_23: G = G::from_u64(196); - let __v_24: G = G::from_u64(70); - let __v_25: G = G::from_u64(94); - let __v_26: G = G::from_u64(209); - let __v_27: G = G::from_u64(127); - let __v_28: G = G::from_u64(224); - let __v_29: G = G::from_u64(196); - let __v_30: G = G::from_u64(220); - let __v_31: G = G::from_u64(134); + let __v_10: G = G::from_u64(239); + let __v_11: G = G::from_u64(87); + let __v_12: G = G::from_u64(218); + let __v_13: G = G::from_u64(145); + let __v_14: G = G::from_u64(178); + let __v_15: G = G::from_u64(104); + let __v_16: G = G::from_u64(143); + let __v_17: G = G::from_u64(252); + let __v_18: G = G::from_u64(167); + let __v_19: G = G::from_u64(197); + let __v_20: G = G::from_u64(67); + let __v_21: G = G::from_u64(91); + let __v_22: G = G::from_u64(181); + let __v_23: G = G::from_u64(220); + let __v_24: G = G::from_u64(44); + let __v_25: G = G::from_u64(177); + let __v_26: G = G::from_u64(26); + let __v_27: G = G::from_u64(104); + let __v_28: G = G::from_u64(163); + let __v_29: G = G::from_u64(49); + let __v_30: G = G::from_u64(134); + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_193] = [__v_32]; record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18618,38 +18626,38 @@ fn aiur_fn_196( unconstrained: bool, ) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(41); - let __v_1: G = G::from_u64(221); - let __v_2: G = G::from_u64(45); - let __v_3: G = G::from_u64(25); - let __v_4: G = G::from_u64(134); - let __v_5: G = G::from_u64(165); - let __v_6: G = G::from_u64(37); - let __v_7: G = G::from_u64(189); - let __v_8: G = G::from_u64(222); - let __v_9: G = G::from_u64(73); - let __v_10: G = G::from_u64(180); - let __v_11: G = G::from_u64(173); - let __v_12: G = G::from_u64(45); - let __v_13: G = G::from_u64(239); - let __v_14: G = G::from_u64(195); - let __v_15: G = G::from_u64(73); - let __v_16: G = G::from_u64(206); - let __v_17: G = G::from_u64(199); - let __v_18: G = G::from_u64(29); - let __v_19: G = G::from_u64(4); - let __v_20: G = G::from_u64(132); - let __v_21: G = G::from_u64(205); - let __v_22: G = G::from_u64(19); - let __v_23: G = G::from_u64(242); - let __v_24: G = G::from_u64(218); - let __v_25: G = G::from_u64(146); - let __v_26: G = G::from_u64(241); - let __v_27: G = G::from_u64(252); - let __v_28: G = G::from_u64(232); - let __v_29: G = G::from_u64(154); - let __v_30: G = G::from_u64(76); - let __v_31: G = G::from_u64(121); + let __v_0: G = G::from_u64(152); + let __v_1: G = G::from_u64(201); + let __v_2: G = G::from_u64(140); + let __v_3: G = G::from_u64(15); + let __v_4: G = G::from_u64(153); + let __v_5: G = G::from_u64(111); + let __v_6: G = G::from_u64(33); + let __v_7: G = G::from_u64(246); + let __v_8: G = G::from_u64(226); + let __v_9: G = G::from_u64(182); + let __v_10: G = G::from_u64(31); + let __v_11: G = G::from_u64(30); + let __v_12: G = G::from_u64(252); + let __v_13: G = G::from_u64(174); + let __v_14: G = G::from_u64(153); + let __v_15: G = G::from_u64(186); + let __v_16: G = G::from_u64(169); + let __v_17: G = G::from_u64(139); + let __v_18: G = G::from_u64(226); + let __v_19: G = G::from_u64(106); + let __v_20: G = G::from_u64(127); + let __v_21: G = G::from_u64(248); + let __v_22: G = G::from_u64(37); + let __v_23: G = G::from_u64(21); + let __v_24: G = G::from_u64(104); + let __v_25: G = G::from_u64(74); + let __v_26: G = G::from_u64(130); + let __v_27: G = G::from_u64(105); + let __v_28: G = G::from_u64(84); + let __v_29: G = G::from_u64(179); + let __v_30: G = G::from_u64(94); + let __v_31: G = G::from_u64(41); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_196] = [__v_32]; record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18667,38 +18675,38 @@ fn aiur_fn_197( unconstrained: bool, ) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(233); - let __v_1: G = G::from_u64(92); - let __v_2: G = G::from_u64(141); - let __v_3: G = G::from_u64(135); - let __v_4: G = G::from_u64(110); - let __v_5: G = G::from_u64(124); - let __v_6: G = G::from_u64(207); - let __v_7: G = G::from_u64(120); - let __v_8: G = G::from_u64(4); - let __v_9: G = G::from_u64(24); - let __v_10: G = G::from_u64(97); - let __v_11: G = G::from_u64(94); - let __v_12: G = G::from_u64(51); - let __v_13: G = G::from_u64(183); - let __v_14: G = G::from_u64(71); - let __v_15: G = G::from_u64(162); - let __v_16: G = G::from_u64(69); - let __v_17: G = G::from_u64(217); - let __v_18: G = G::from_u64(79); - let __v_19: G = G::from_u64(172); - let __v_20: G = G::from_u64(215); - let __v_21: G = G::from_u64(86); + let __v_0: G = G::from_u64(208); + let __v_1: G = G::from_u64(127); + let __v_2: G = G::from_u64(129); + let __v_3: G = G::from_u64(5); + let __v_4: G = G::from_u64(197); + let __v_5: G = G::from_u64(68); + let __v_6: G = G::from_u64(34); + let __v_7: G = G::from_u64(122); + let __v_8: G = G::from_u64(19); + let __v_9: G = G::from_u64(236); + let __v_10: G = G::from_u64(144); + let __v_11: G = G::from_u64(190); + let __v_12: G = G::from_u64(250); + let __v_13: G = G::from_u64(226); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(94); + let __v_16: G = G::from_u64(156); + let __v_17: G = G::from_u64(111); + let __v_18: G = G::from_u64(100); + let __v_19: G = G::from_u64(73); + let __v_20: G = G::from_u64(63); + let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(127); - let __v_23: G = G::from_u64(236); - let __v_24: G = G::from_u64(190); - let __v_25: G = G::from_u64(122); - let __v_26: G = G::from_u64(231); - let __v_27: G = G::from_u64(58); - let __v_28: G = G::from_u64(90); - let __v_29: G = G::from_u64(192); - let __v_30: G = G::from_u64(146); - let __v_31: G = G::from_u64(6); + let __v_23: G = G::from_u64(246); + let __v_24: G = G::from_u64(105); + let __v_25: G = G::from_u64(186); + let __v_26: G = G::from_u64(116); + let __v_27: G = G::from_u64(62); + let __v_28: G = G::from_u64(21); + let __v_29: G = G::from_u64(71); + let __v_30: G = G::from_u64(201); + let __v_31: G = G::from_u64(53); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_197] = [__v_32]; record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18716,38 +18724,38 @@ fn aiur_fn_198( unconstrained: bool, ) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(107); - let __v_1: G = G::from_u64(182); - let __v_2: G = G::from_u64(22); - let __v_3: G = G::from_u64(42); - let __v_4: G = G::from_u64(172); - let __v_5: G = G::from_u64(125); - let __v_6: G = G::from_u64(106); - let __v_7: G = G::from_u64(1); - let __v_8: G = G::from_u64(182); - let __v_9: G = G::from_u64(236); - let __v_10: G = G::from_u64(5); - let __v_11: G = G::from_u64(88); - let __v_12: G = G::from_u64(6); - let __v_13: G = G::from_u64(100); - let __v_14: G = G::from_u64(232); - let __v_15: G = G::from_u64(167); - let __v_16: G = G::from_u64(240); - let __v_17: G = G::from_u64(212); - let __v_18: G = G::from_u64(176); - let __v_19: G = G::from_u64(236); - let __v_20: G = G::from_u64(31); - let __v_21: G = G::from_u64(197); - let __v_22: G = G::from_u64(175); - let __v_23: G = G::from_u64(170); - let __v_24: G = G::from_u64(230); - let __v_25: G = G::from_u64(96); - let __v_26: G = G::from_u64(24); - let __v_27: G = G::from_u64(233); - let __v_28: G = G::from_u64(161); - let __v_29: G = G::from_u64(147); - let __v_30: G = G::from_u64(109); - let __v_31: G = G::from_u64(172); + let __v_0: G = G::from_u64(252); + let __v_1: G = G::from_u64(73); + let __v_2: G = G::from_u64(53); + let __v_3: G = G::from_u64(122); + let __v_4: G = G::from_u64(91); + let __v_5: G = G::from_u64(198); + let __v_6: G = G::from_u64(82); + let __v_7: G = G::from_u64(88); + let __v_8: G = G::from_u64(57); + let __v_9: G = G::from_u64(167); + let __v_10: G = G::from_u64(188); + let __v_11: G = G::from_u64(17); + let __v_12: G = G::from_u64(185); + let __v_13: G = G::from_u64(223); + let __v_14: G = G::from_u64(32); + let __v_15: G = G::from_u64(120); + let __v_16: G = G::from_u64(82); + let __v_17: G = G::from_u64(166); + let __v_18: G = G::from_u64(233); + let __v_19: G = G::from_u64(198); + let __v_20: G = G::from_u64(175); + let __v_21: G = G::from_u64(163); + let __v_22: G = G::from_u64(236); + let __v_23: G = G::from_u64(98); + let __v_24: G = G::from_u64(186); + let __v_25: G = G::from_u64(195); + let __v_26: G = G::from_u64(197); + let __v_27: G = G::from_u64(66); + let __v_28: G = G::from_u64(172); + let __v_29: G = G::from_u64(137); + let __v_30: G = G::from_u64(224); + let __v_31: G = G::from_u64(224); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_198] = [__v_32]; record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18765,38 +18773,38 @@ fn aiur_fn_199( unconstrained: bool, ) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(237); - let __v_1: G = G::from_u64(67); - let __v_2: G = G::from_u64(199); - let __v_3: G = G::from_u64(126); - let __v_4: G = G::from_u64(85); - let __v_5: G = G::from_u64(85); - let __v_6: G = G::from_u64(147); - let __v_7: G = G::from_u64(182); - let __v_8: G = G::from_u64(205); - let __v_9: G = G::from_u64(13); - let __v_10: G = G::from_u64(75); - let __v_11: G = G::from_u64(251); - let __v_12: G = G::from_u64(196); - let __v_13: G = G::from_u64(39); - let __v_14: G = G::from_u64(59); - let __v_15: G = G::from_u64(161); - let __v_16: G = G::from_u64(34); - let __v_17: G = G::from_u64(225); - let __v_18: G = G::from_u64(192); - let __v_19: G = G::from_u64(205); - let __v_20: G = G::from_u64(241); - let __v_21: G = G::from_u64(9); - let __v_22: G = G::from_u64(5); - let __v_23: G = G::from_u64(113); - let __v_24: G = G::from_u64(97); - let __v_25: G = G::from_u64(42); - let __v_26: G = G::from_u64(149); - let __v_27: G = G::from_u64(47); - let __v_28: G = G::from_u64(148); - let __v_29: G = G::from_u64(30); - let __v_30: G = G::from_u64(173); - let __v_31: G = G::from_u64(177); + let __v_0: G = G::from_u64(53); + let __v_1: G = G::from_u64(212); + let __v_2: G = G::from_u64(243); + let __v_3: G = G::from_u64(130); + let __v_4: G = G::from_u64(226); + let __v_5: G = G::from_u64(78); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(156); + let __v_8: G = G::from_u64(192); + let __v_9: G = G::from_u64(233); + let __v_10: G = G::from_u64(69); + let __v_11: G = G::from_u64(121); + let __v_12: G = G::from_u64(85); + let __v_13: G = G::from_u64(211); + let __v_14: G = G::from_u64(239); + let __v_15: G = G::from_u64(30); + let __v_16: G = G::from_u64(111); + let __v_17: G = G::from_u64(121); + let __v_18: G = G::from_u64(250); + let __v_19: G = G::from_u64(233); + let __v_20: G = G::from_u64(216); + let __v_21: G = G::from_u64(211); + let __v_22: G = G::from_u64(28); + let __v_23: G = G::from_u64(253); + let __v_24: G = G::from_u64(46); + let __v_25: G = G::from_u64(21); + let __v_26: G = G::from_u64(63); + let __v_27: G = G::from_u64(160); + let __v_28: G = G::from_u64(59); + let __v_29: G = G::from_u64(5); + let __v_30: G = G::from_u64(74); + let __v_31: G = G::from_u64(106); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_199] = [__v_32]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18814,38 +18822,38 @@ fn aiur_fn_200( unconstrained: bool, ) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(124); - let __v_1: G = G::from_u64(251); - let __v_2: G = G::from_u64(168); - let __v_3: G = G::from_u64(250); - let __v_4: G = G::from_u64(149); - let __v_5: G = G::from_u64(132); - let __v_6: G = G::from_u64(124); - let __v_7: G = G::from_u64(33); - let __v_8: G = G::from_u64(58); - let __v_9: G = G::from_u64(164); - let __v_10: G = G::from_u64(6); - let __v_11: G = G::from_u64(97); - let __v_12: G = G::from_u64(16); - let __v_13: G = G::from_u64(186); - let __v_14: G = G::from_u64(1); - let __v_15: G = G::from_u64(169); - let __v_16: G = G::from_u64(127); - let __v_17: G = G::from_u64(181); - let __v_18: G = G::from_u64(151); - let __v_19: G = G::from_u64(218); - let __v_20: G = G::from_u64(242); - let __v_21: G = G::from_u64(159); - let __v_22: G = G::from_u64(92); - let __v_23: G = G::from_u64(7); - let __v_24: G = G::from_u64(247); - let __v_25: G = G::from_u64(35); - let __v_26: G = G::from_u64(102); - let __v_27: G = G::from_u64(7); - let __v_28: G = G::from_u64(47); - let __v_29: G = G::from_u64(37); - let __v_30: G = G::from_u64(7); - let __v_31: G = G::from_u64(68); + let __v_0: G = G::from_u64(226); + let __v_1: G = G::from_u64(28); + let __v_2: G = G::from_u64(36); + let __v_3: G = G::from_u64(180); + let __v_4: G = G::from_u64(47); + let __v_5: G = G::from_u64(4); + let __v_6: G = G::from_u64(146); + let __v_7: G = G::from_u64(57); + let __v_8: G = G::from_u64(199); + let __v_9: G = G::from_u64(247); + let __v_10: G = G::from_u64(51); + let __v_11: G = G::from_u64(146); + let __v_12: G = G::from_u64(254); + let __v_13: G = G::from_u64(220); + let __v_14: G = G::from_u64(145); + let __v_15: G = G::from_u64(31); + let __v_16: G = G::from_u64(87); + let __v_17: G = G::from_u64(76); + let __v_18: G = G::from_u64(121); + let __v_19: G = G::from_u64(131); + let __v_20: G = G::from_u64(134); + let __v_21: G = G::from_u64(203); + let __v_22: G = G::from_u64(227); + let __v_23: G = G::from_u64(227); + let __v_24: G = G::from_u64(226); + let __v_25: G = G::from_u64(162); + let __v_26: G = G::from_u64(136); + let __v_27: G = G::from_u64(142); + let __v_28: G = G::from_u64(45); + let __v_29: G = G::from_u64(243); + let __v_30: G = G::from_u64(174); + let __v_31: G = G::from_u64(240); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_200] = [__v_32]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18863,38 +18871,38 @@ fn aiur_fn_201( unconstrained: bool, ) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(130); - let __v_1: G = G::from_u64(229); - let __v_2: G = G::from_u64(86); - let __v_3: G = G::from_u64(141); - let __v_4: G = G::from_u64(136); - let __v_5: G = G::from_u64(226); - let __v_6: G = G::from_u64(79); - let __v_7: G = G::from_u64(36); - let __v_8: G = G::from_u64(213); - let __v_9: G = G::from_u64(190); - let __v_10: G = G::from_u64(250); - let __v_11: G = G::from_u64(195); - let __v_12: G = G::from_u64(12); - let __v_13: G = G::from_u64(233); - let __v_14: G = G::from_u64(21); - let __v_15: G = G::from_u64(1); - let __v_16: G = G::from_u64(14); - let __v_17: G = G::from_u64(146); - let __v_18: G = G::from_u64(89); - let __v_19: G = G::from_u64(111); - let __v_20: G = G::from_u64(85); - let __v_21: G = G::from_u64(168); - let __v_22: G = G::from_u64(34); - let __v_23: G = G::from_u64(226); - let __v_24: G = G::from_u64(159); - let __v_25: G = G::from_u64(72); - let __v_26: G = G::from_u64(118); - let __v_27: G = G::from_u64(234); - let __v_28: G = G::from_u64(58); - let __v_29: G = G::from_u64(87); - let __v_30: G = G::from_u64(147); - let __v_31: G = G::from_u64(148); + let __v_0: G = G::from_u64(186); + let __v_1: G = G::from_u64(81); + let __v_2: G = G::from_u64(181); + let __v_3: G = G::from_u64(216); + let __v_4: G = G::from_u64(163); + let __v_5: G = G::from_u64(177); + let __v_6: G = G::from_u64(66); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(210); + let __v_9: G = G::from_u64(36); + let __v_10: G = G::from_u64(2); + let __v_11: G = G::from_u64(205); + let __v_12: G = G::from_u64(168); + let __v_13: G = G::from_u64(231); + let __v_14: G = G::from_u64(49); + let __v_15: G = G::from_u64(228); + let __v_16: G = G::from_u64(159); + let __v_17: G = G::from_u64(223); + let __v_18: G = G::from_u64(120); + let __v_19: G = G::from_u64(240); + let __v_20: G = G::from_u64(139); + let __v_21: G = G::from_u64(114); + let __v_22: G = G::from_u64(100); + let __v_23: G = G::from_u64(60); + let __v_24: G = G::from_u64(27); + let __v_25: G = G::from_u64(8); + let __v_26: G = G::from_u64(226); + let __v_27: G = G::from_u64(80); + let __v_28: G = G::from_u64(67); + let __v_29: G = G::from_u64(106); + let __v_30: G = G::from_u64(175); + let __v_31: G = G::from_u64(241); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_201] = [__v_32]; record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18912,38 +18920,38 @@ fn aiur_fn_202( unconstrained: bool, ) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(122); - let __v_1: G = G::from_u64(178); - let __v_2: G = G::from_u64(213); - let __v_3: G = G::from_u64(42); - let __v_4: G = G::from_u64(197); - let __v_5: G = G::from_u64(47); - let __v_6: G = G::from_u64(209); - let __v_7: G = G::from_u64(245); - let __v_8: G = G::from_u64(24); - let __v_9: G = G::from_u64(9); - let __v_10: G = G::from_u64(183); - let __v_11: G = G::from_u64(24); - let __v_12: G = G::from_u64(229); - let __v_13: G = G::from_u64(60); - let __v_14: G = G::from_u64(208); - let __v_15: G = G::from_u64(88); - let __v_16: G = G::from_u64(172); - let __v_17: G = G::from_u64(75); - let __v_18: G = G::from_u64(80); - let __v_19: G = G::from_u64(214); - let __v_20: G = G::from_u64(81); - let __v_21: G = G::from_u64(80); - let __v_22: G = G::from_u64(231); - let __v_23: G = G::from_u64(138); - let __v_24: G = G::from_u64(230); - let __v_25: G = G::from_u64(25); - let __v_26: G = G::from_u64(19); - let __v_27: G = G::from_u64(156); - let __v_28: G = G::from_u64(207); - let __v_29: G = G::from_u64(19); - let __v_30: G = G::from_u64(200); - let __v_31: G = G::from_u64(253); + let __v_0: G = G::from_u64(74); + let __v_1: G = G::from_u64(192); + let __v_2: G = G::from_u64(158); + let __v_3: G = G::from_u64(216); + let __v_4: G = G::from_u64(255); + let __v_5: G = G::from_u64(97); + let __v_6: G = G::from_u64(228); + let __v_7: G = G::from_u64(79); + let __v_8: G = G::from_u64(17); + let __v_9: G = G::from_u64(89); + let __v_10: G = G::from_u64(188); + let __v_11: G = G::from_u64(111); + let __v_12: G = G::from_u64(176); + let __v_13: G = G::from_u64(15); + let __v_14: G = G::from_u64(215); + let __v_15: G = G::from_u64(231); + let __v_16: G = G::from_u64(44); + let __v_17: G = G::from_u64(21); + let __v_18: G = G::from_u64(222); + let __v_19: G = G::from_u64(239); + let __v_20: G = G::from_u64(234); + let __v_21: G = G::from_u64(86); + let __v_22: G = G::from_u64(157); + let __v_23: G = G::from_u64(117); + let __v_24: G = G::from_u64(93); + let __v_25: G = G::from_u64(139); + let __v_26: G = G::from_u64(29); + let __v_27: G = G::from_u64(5); + let __v_28: G = G::from_u64(245); + let __v_29: G = G::from_u64(209); + let __v_30: G = G::from_u64(145); + let __v_31: G = G::from_u64(247); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_202] = [__v_32]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19080,7 +19088,7 @@ fn aiur_fn_204( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -19091,7 +19099,7 @@ fn aiur_fn_204( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -19156,7 +19164,7 @@ fn aiur_fn_204( }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -19167,7 +19175,7 @@ fn aiur_fn_204( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; @@ -19257,7 +19265,7 @@ fn aiur_fn_204( let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_204] = [__v_16, __v_17]; @@ -19286,10 +19294,10 @@ fn aiur_fn_204( }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -19309,7 +19317,7 @@ fn aiur_fn_204( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); @@ -19407,7 +19415,7 @@ fn aiur_fn_205( ) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -19424,7 +19432,7 @@ fn aiur_fn_205( }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -19498,7 +19506,7 @@ fn aiur_fn_206( ) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -19515,7 +19523,7 @@ fn aiur_fn_206( }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -20070,7 +20078,7 @@ fn aiur_fn_214( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -20080,9 +20088,9 @@ fn aiur_fn_214( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_33]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20092,7 +20100,7 @@ fn aiur_fn_214( let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_34]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20264,7 +20272,7 @@ fn aiur_fn_218( 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_383] = { let __args: [G; IN_383] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -20282,7 +20290,7 @@ fn aiur_fn_218( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -20321,12 +20329,12 @@ fn aiur_fn_218( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_719] = { let __args: [G; IN_719] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; @@ -20343,7 +20351,7 @@ fn aiur_fn_218( }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; @@ -20424,7 +20432,7 @@ fn aiur_fn_219( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -21549,7 +21557,7 @@ fn aiur_fn_230( match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; @@ -21647,17 +21655,17 @@ fn aiur_fn_231( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_719] = { let __args: [G; IN_719] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -21974,14 +21982,14 @@ fn aiur_fn_235( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_719] = { let __args: [G; IN_719] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -22068,7 +22076,7 @@ fn aiur_fn_236( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -22088,7 +22096,7 @@ fn aiur_fn_236( 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_719] = { let __args: [G; IN_719] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -22104,11 +22112,11 @@ fn aiur_fn_236( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __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_728] = { let __args: [G; IN_728] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -22160,7 +22168,7 @@ fn aiur_fn_237( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -22187,7 +22195,7 @@ fn aiur_fn_237( }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -22195,7 +22203,7 @@ fn aiur_fn_237( match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; @@ -22240,7 +22248,7 @@ fn aiur_fn_237( }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -22248,7 +22256,7 @@ fn aiur_fn_237( match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; @@ -22319,10 +22327,10 @@ fn aiur_fn_238( }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -22340,7 +22348,7 @@ fn aiur_fn_238( match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; @@ -22459,7 +22467,7 @@ fn aiur_fn_239( }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -22970,7 +22978,7 @@ fn aiur_fn_245( 0u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; @@ -23027,7 +23035,7 @@ fn aiur_fn_246( 0u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; @@ -23051,7 +23059,7 @@ fn aiur_fn_246( 2u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; @@ -23065,7 +23073,7 @@ fn aiur_fn_246( 3u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; @@ -23079,7 +23087,7 @@ fn aiur_fn_246( 4u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; @@ -23094,7 +23102,7 @@ fn aiur_fn_246( 5u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; @@ -23110,7 +23118,7 @@ fn aiur_fn_246( 6u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; @@ -23176,7 +23184,7 @@ fn aiur_fn_246( 11u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -24493,7 +24501,7 @@ fn aiur_fn_262( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -27036,8 +27044,8 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 2; -const IN_288: usize = 2; +const INPUT_SIZE_288: usize = 1; +const IN_288: usize = 1; const OUT_288: usize = 1; fn aiur_fn_288( inp: [G; IN_288], @@ -27047,100 +27055,172 @@ fn aiur_fn_288( ) -> 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - match __v_2.as_canonical_u64() { + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_5: G = __loaded[0]; - let __v_6: G = __loaded[1]; - let __v_7: G = __loaded[2]; - match __v_5.as_canonical_u64() { + let __ret: [G; OUT_288] = [__v_0]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __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_288] = { let __args: [G; IN_288] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_288] = [__v_10]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_288] = [__v_0]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_288] = [__v_0]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_289: usize = 2; +const IN_289: usize = 2; +const OUT_289: usize = 1; +fn aiur_fn_289( + inp: [G; IN_289], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_289], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __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_8: G = G::from_u64(1); - let __ret: [G; OUT_288] = [__v_8]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_289] = [__v_10]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_288] = [__v_8]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_289] = [__v_10]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_5: G = __loaded[0]; - let __v_6: G = __loaded[1]; - let __v_7: G = __loaded[2]; - match __v_5.as_canonical_u64() { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_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_8: G = G::from_u64(0); - let __ret: [G; OUT_288] = [__v_8]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_289] = [__v_10]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_8: G = __loaded[0]; - let __v_9: G = __loaded[1]; - let __v_10: G = __loaded[2]; - match __v_8.as_canonical_u64() { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_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_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_11: G = __loaded[0]; - let __v_12: G = __loaded[1]; - let __v_13: G = __loaded[2]; - match __v_11.as_canonical_u64() { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __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_273] = { let __args: [G; IN_273] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - match __v_14.as_canonical_u64() { + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { 0u64 => { - let __v_15: G = (__v_9 - __v_12); - match __v_15.as_canonical_u64() { + let __v_17: G = (__v_11 - __v_14); + match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; - let __v_16: G = __r_arr[0]; - match __v_16.as_canonical_u64() { + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_17]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_289] = [__v_19]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_288] = [__v_17]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_289] = [__v_19]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { - let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_288] = [__v_16]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_289] = [__v_18]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_288] = [__v_15]; - record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_289] = [__v_17]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -27150,26 +27230,26 @@ fn aiur_fn_288( } }, _ => { - return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_289: usize = 3; -const IN_289: usize = 3; -const OUT_289: usize = 1; -fn aiur_fn_289( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { +) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27181,8 +27261,8 @@ fn aiur_fn_289( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_289] = [__v_6]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_290] = [__v_6]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -27196,10 +27276,10 @@ fn aiur_fn_289( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_10]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_290] = [__v_10]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27210,7 +27290,7 @@ fn aiur_fn_289( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -27223,15 +27303,15 @@ fn aiur_fn_289( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_289] = [__v_12]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_290] = [__v_12]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_12]; - record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_290] = [__v_12]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27250,15 +27330,15 @@ fn aiur_fn_289( }) } -const INPUT_SIZE_290: usize = 2; -const IN_290: usize = 2; -const OUT_290: usize = 1; -fn aiur_fn_290( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27269,8 +27349,8 @@ fn aiur_fn_290( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_290] = [__v_5]; - record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_291] = [__v_5]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -27285,15 +27365,15 @@ fn aiur_fn_290( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_290] = [__v_10]; - record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_291] = [__v_10]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_290] = [__v_10]; - record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_291] = [__v_10]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27310,15 +27390,15 @@ fn aiur_fn_290( }) } -const INPUT_SIZE_291: usize = 4; -const IN_291: usize = 4; -const OUT_291: usize = 1; -fn aiur_fn_291( - inp: [G; IN_291], +const INPUT_SIZE_292: usize = 4; +const IN_292: usize = 4; +const OUT_292: usize = 1; +fn aiur_fn_292( + inp: [G; IN_292], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_291], ExecError> { +) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27331,8 +27411,8 @@ fn aiur_fn_291( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_291] = [__v_7]; - record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_7]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -27346,27 +27426,27 @@ fn aiur_fn_291( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_291] = [__v_11]; - record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_11]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_291] = [__v_12]; - record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_12]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_291] = [__v_12]; - record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_292] = [__v_12]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27385,15 +27465,15 @@ fn aiur_fn_291( }) } -const INPUT_SIZE_292: usize = 3; -const IN_292: usize = 3; -const OUT_292: usize = 1; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_293: usize = 3; +const IN_293: usize = 3; +const OUT_293: usize = 1; +fn aiur_fn_293( + inp: [G; IN_293], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], ExecError> { +) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27405,8 +27485,8 @@ fn aiur_fn_292( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_292] = [__v_6]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_6]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -27422,15 +27502,15 @@ fn aiur_fn_292( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_292] = [__v_10]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_10]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_292] = [__v_10]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_10]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27439,10 +27519,10 @@ fn aiur_fn_292( } }, _ => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_292] = [__v_9]; - record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_293] = [__v_9]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -27456,15 +27536,15 @@ fn aiur_fn_292( }) } -const INPUT_SIZE_293: usize = 2; -const IN_293: usize = 2; -const OUT_293: usize = 1; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_294: usize = 2; +const IN_294: usize = 2; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], ExecError> { +) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27475,8 +27555,8 @@ fn aiur_fn_293( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_293] = [__v_5]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_294] = [__v_5]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -27492,7 +27572,7 @@ fn aiur_fn_293( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -27502,25 +27582,25 @@ fn aiur_fn_293( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_9]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_294] = [__v_9]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_10]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_294] = [__v_10]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_293] = [__v_10]; - record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_294] = [__v_10]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27542,15 +27622,15 @@ fn aiur_fn_293( }) } -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_295: usize = 3; +const IN_295: usize = 3; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27562,8 +27642,8 @@ fn aiur_fn_294( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_294] = [__v_6]; - record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_295] = [__v_6]; + record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -27572,20 +27652,20 @@ fn aiur_fn_294( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_9]; - record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_295] = [__v_9]; + record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_9]; - record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_295] = [__v_9]; + record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27602,15 +27682,15 @@ fn aiur_fn_294( }) } -const INPUT_SIZE_295: usize = 1; -const IN_295: usize = 1; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_296: usize = 1; +const IN_296: usize = 1; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], ExecError> { +) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -27634,65 +27714,12 @@ fn aiur_fn_295( let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_295] = [__v_19]; - record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_296] = [__v_19]; + record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_296: usize = 2; -const IN_296: usize = 2; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_296], 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_272] = { let __args: [G; IN_272] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - match __v_2.as_canonical_u64() { - 1u64 => { - let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_3]; - record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_3: G = __loaded[0]; - let __v_4: G = __loaded[1]; - let __v_5: G = __loaded[2]; - match __v_3.as_canonical_u64() { - 0u64 => { - let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_6]; - record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_8]; - record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }) -} - const INPUT_SIZE_297: usize = 2; const IN_297: usize = 2; const OUT_297: usize = 1; @@ -27715,15 +27742,29 @@ fn aiur_fn_297( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_5]; - record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_297] = [__v_6]; + record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_297] = [__v_8]; + record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); @@ -27744,12 +27785,51 @@ fn aiur_fn_298( 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_303] = { let __args: [G; IN_303] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_298] = [__v_3]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_298] = [__v_5]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_299: usize = 2; +const IN_299: usize = 2; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: [G; IN_299], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_299], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -27757,13 +27837,13 @@ fn aiur_fn_298( 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_298] = [__v_1]; - record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_1]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_298] = [__v_0]; - record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_0]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27772,43 +27852,43 @@ fn aiur_fn_298( } }, _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_6]; - record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_6]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_4]; - record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_299] = [__v_4]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_300: usize = 2; +const IN_300: usize = 2; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { +) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_299] = [__v_0]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_0]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -27818,8 +27898,8 @@ fn aiur_fn_299( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_299] = [__v_1]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_1]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27829,33 +27909,33 @@ fn aiur_fn_299( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_299] = [__v_0]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_0]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_299] = [__v_1]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_1]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_299] = [__v_0]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_0]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_11]; - record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_300] = [__v_11]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27879,15 +27959,15 @@ fn aiur_fn_299( }) } -const INPUT_SIZE_300: usize = 2; -const IN_300: usize = 2; -const OUT_300: usize = 1; -fn aiur_fn_300( - inp: [G; IN_300], +const INPUT_SIZE_301: usize = 2; +const IN_301: usize = 2; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27895,8 +27975,8 @@ fn aiur_fn_300( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_300] = [__v_3]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_3]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -27913,14 +27993,14 @@ fn aiur_fn_300( match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -27932,16 +28012,16 @@ fn aiur_fn_300( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -27953,19 +28033,19 @@ fn aiur_fn_300( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_300] = [__v_11]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_11]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -27977,19 +28057,19 @@ fn aiur_fn_300( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_300] = [__v_11]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_11]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28005,22 +28085,22 @@ fn aiur_fn_300( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_300] = [__v_10]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_10]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_10]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_10]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28034,15 +28114,15 @@ 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_302: usize = 2; +const IN_302: usize = 2; +const OUT_302: usize = 1; +fn aiur_fn_302( + inp: [G; IN_302], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], ExecError> { +) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28052,20 +28132,20 @@ fn aiur_fn_301( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_6]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_302] = [__v_6]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_301] = [__v_6]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_302] = [__v_6]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28075,48 +28155,48 @@ fn aiur_fn_301( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_5]; - record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_302] = [__v_5]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 1; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_303: usize = 2; +const IN_303: usize = 2; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: [G; IN_303], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], ExecError> { +) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_302] = [__v_1]; - record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_303] = [__v_1]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_302] = [__v_0]; - record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_303] = [__v_0]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28127,8 +28207,8 @@ fn aiur_fn_302( 0u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_10]; - record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_303] = [__v_10]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28138,15 +28218,15 @@ fn aiur_fn_302( }) } -const INPUT_SIZE_303: usize = 1; -const IN_303: usize = 1; -const OUT_303: usize = 2; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_304: usize = 1; +const IN_304: usize = 1; +const OUT_304: usize = 2; +fn aiur_fn_304( + inp: [G; IN_304], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_303], ExecError> { +) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -28157,12 +28237,12 @@ fn aiur_fn_303( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_303] = [__v_4, __v_5]; - record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_304] = [__v_4, __v_5]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -28170,15 +28250,15 @@ fn aiur_fn_303( 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_303] = [__v_6, __v_8]; - record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_304] = [__v_6, __v_8]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_303] = [__v_6, __v_7]; - record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_304] = [__v_6, __v_7]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28186,23 +28266,23 @@ fn aiur_fn_303( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_303] = [__v_4, __v_5]; - record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_304] = [__v_4, __v_5]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_304: usize = 2; -const IN_304: usize = 2; -const OUT_304: usize = 2; -fn aiur_fn_304( - inp: [G; IN_304], +const INPUT_SIZE_305: usize = 2; +const IN_305: usize = 2; +const OUT_305: usize = 2; +fn aiur_fn_305( + inp: [G; IN_305], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_304], ExecError> { +) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28214,31 +28294,31 @@ fn aiur_fn_304( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_304] = [__v_7, __v_8]; - record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_305] = [__v_7, __v_8]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_304] = [__v_0, __v_1]; - record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_305] = [__v_0, __v_1]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_305: usize = 2; -const IN_305: usize = 2; -const OUT_305: usize = 1; -fn aiur_fn_305( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_305], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28251,15 +28331,15 @@ fn aiur_fn_305( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_7]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_7]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_305] = [__v_5]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_5]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28267,10 +28347,10 @@ fn aiur_fn_305( let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_305] = [__v_6]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_6]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -28280,8 +28360,8 @@ fn aiur_fn_305( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_305] = [__v_1]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_1]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28289,15 +28369,15 @@ fn aiur_fn_305( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_305] = [__v_0]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_0]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_11]; - record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_306] = [__v_11]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28316,15 +28396,15 @@ fn aiur_fn_305( }) } -const INPUT_SIZE_306: usize = 1; -const IN_306: usize = 1; -const OUT_306: usize = 1; -fn aiur_fn_306( - inp: [G; IN_306], +const INPUT_SIZE_307: usize = 1; +const IN_307: usize = 1; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_306], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -28336,123 +28416,52 @@ fn aiur_fn_306( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_6]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_307] = [__v_6]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_6]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_307] = [__v_6]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_7]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 2u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_6]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 3u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_6]; - record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_307: usize = 2; -const IN_307: usize = 2; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - match __v_2.as_canonical_u64() { - 0u64 => { - let __v_5: G = G::from_u64(0); - let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_307] = [__v_7]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, - 1u64 => { - let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_8]; - record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, 2u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_7]; + let __ret: [G; OUT_307] = [__v_6]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_7]; - record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 4u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_5]; + let __ret: [G; OUT_307] = [__v_6]; record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) @@ -28475,25 +28484,53 @@ fn aiur_fn_308( let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { - 1u64 => { - let __v_5: G = G::from_u64(1); - let __v_6: G = G::from_u64(1); + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_308] = [__v_7]; record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, - 0u64 => { - let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + 1u64 => { + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_308] = [__v_8]; record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, + 2u64 => { + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_308] = [__v_7]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_308] = [__v_7]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_308] = [__v_5]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, @@ -28513,23 +28550,33 @@ fn aiur_fn_309( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_309] = [__v_0]; + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_309] = [__v_7]; record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, - _ => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_5]; + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_309] = [__v_8]; record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, } }) } @@ -28543,6 +28590,39 @@ fn aiur_fn_310( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_310] = [__v_0]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_310] = [__v_5]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_311: usize = 2; +const IN_311: usize = 2; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: [G; IN_311], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28556,94 +28636,94 @@ fn aiur_fn_310( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_8]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_8]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_9]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_9]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_9]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_9]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_10]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_10]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_10]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_10]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_10]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_10]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_10]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_10]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_8]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_8]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_8]; - record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_311] = [__v_8]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28653,15 +28733,15 @@ fn aiur_fn_310( }) } -const INPUT_SIZE_311: usize = 2; -const IN_311: usize = 2; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_312: usize = 2; +const IN_312: usize = 2; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], ExecError> { +) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28692,14 +28772,14 @@ fn aiur_fn_311( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_311] = [__v_22]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_22]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_22]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_22]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28719,8 +28799,8 @@ fn aiur_fn_311( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_22]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_22]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -28728,16 +28808,16 @@ fn aiur_fn_311( let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_23]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_23]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_23]; - record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_312] = [__v_23]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28757,15 +28837,15 @@ 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_313: usize = 2; +const IN_313: usize = 2; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: [G; IN_313], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_312], ExecError> { +) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28782,14 +28862,14 @@ fn aiur_fn_312( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_312] = [__v_8]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_8]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_8]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_8]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28802,24 +28882,24 @@ fn aiur_fn_312( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_8]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_8]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_9]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_9]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_9]; - record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_313] = [__v_9]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28836,15 +28916,15 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 4; -const IN_313: usize = 4; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_314: usize = 4; +const IN_314: usize = 4; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_313], ExecError> { +) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28854,16 +28934,16 @@ fn aiur_fn_313( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_4]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_4]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_313] = [__v_4]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_4]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28871,16 +28951,16 @@ fn aiur_fn_313( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_4]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_4]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_313] = [__v_4]; - record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_314] = [__v_4]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -28892,15 +28972,15 @@ 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_315: usize = 1; +const IN_315: usize = 1; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_314], ExecError> { +) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -28912,77 +28992,77 @@ fn aiur_fn_314( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_314] = [__v_6]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_6]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_5]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_5]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_5]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_5]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_5]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_5]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_7]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_7]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_8]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_8]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_8]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_8]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_5]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_5]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_5]; - record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_315] = [__v_5]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -28992,59 +29072,59 @@ fn aiur_fn_314( }) } -const INPUT_SIZE_315: usize = 3; -const IN_315: usize = 3; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_316: usize = 3; +const IN_316: usize = 3; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: [G; IN_316], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_8]; - record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_316] = [__v_8]; + record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_316: usize = 2; -const IN_316: usize = 2; -const OUT_316: usize = 1; -fn aiur_fn_316( - inp: [G; IN_316], +const INPUT_SIZE_317: usize = 2; +const IN_317: usize = 2; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: [G; IN_317], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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_316] = [__v_1]; - record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_317] = [__v_1]; + record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_316] = [__v_0]; - record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_317] = [__v_0]; + record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29054,57 +29134,57 @@ fn aiur_fn_316( }) } -const INPUT_SIZE_317: usize = 1; -const IN_317: usize = 1; -const OUT_317: usize = 1; -fn aiur_fn_317( - inp: [G; IN_317], +const INPUT_SIZE_318: usize = 1; +const IN_318: usize = 1; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: [G; IN_318], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_317], ExecError> { +) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_1]; - record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_318] = [__v_1]; + record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_317] = [__v_2]; - record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_318] = [__v_2]; + record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_318: usize = 2; -const IN_318: usize = 2; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_319: usize = 2; +const IN_319: usize = 2; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_318] = [__v_0]; - record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_319] = [__v_0]; + record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_318] = [__v_1]; - record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_319] = [__v_1]; + record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29114,34 +29194,34 @@ fn aiur_fn_318( }) } -const INPUT_SIZE_319: usize = 2; -const IN_319: usize = 2; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], +const INPUT_SIZE_320: usize = 2; +const IN_320: usize = 2; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: [G; IN_320], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_319], ExecError> { +) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_319] = [__v_2]; - record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_320] = [__v_2]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_320: usize = 3; -const IN_320: usize = 3; -const OUT_320: usize = 1; -fn aiur_fn_320( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_320], ExecError> { +) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29157,14 +29237,14 @@ fn aiur_fn_320( match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_8]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_8]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!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_320] = [__v_8]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_8]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29174,37 +29254,37 @@ fn aiur_fn_320( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_7]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_7]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_7]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_7]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_7]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_7]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_320] = [__v_8]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_8]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_8]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_8]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29213,31 +29293,31 @@ fn aiur_fn_320( } }, 4u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_7]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_7]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_7]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_7]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_7]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_7]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_7]; - record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_321] = [__v_7]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29247,27 +29327,27 @@ fn aiur_fn_320( }) } -const INPUT_SIZE_321: usize = 4; -const IN_321: usize = 4; -const OUT_321: usize = 1; -fn aiur_fn_321( - inp: [G; IN_321], +const INPUT_SIZE_322: usize = 4; +const IN_322: usize = 4; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_321], ExecError> { +) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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_320] = { let __args: [G; IN_320] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_321] = [__v_5]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_322] = [__v_5]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -29275,10 +29355,10 @@ fn aiur_fn_321( 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_320] = { let __args: [G; IN_320] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_9]; - record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_322] = [__v_9]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29288,38 +29368,38 @@ fn aiur_fn_321( }) } -const INPUT_SIZE_322: usize = 5; -const IN_322: usize = 5; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_323: usize = 5; +const IN_323: usize = 5; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_322] = [__v_6]; - record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_323] = [__v_6]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_322] = [__v_7]; - record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_323] = [__v_7]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -29327,10 +29407,10 @@ fn aiur_fn_322( 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_320] = { let __args: [G; IN_320] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_11]; - record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_323] = [__v_11]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29345,60 +29425,60 @@ fn aiur_fn_322( }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: [G; IN_324], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_323] = [__v_4]; - record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_324] = [__v_4]; + record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324( - inp: [G; IN_324], +const INPUT_SIZE_325: usize = 2; +const IN_325: usize = 2; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: [G; IN_325], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_324] = [__v_2]; - record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_325] = [__v_2]; + record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_324] = [__v_7]; - record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_325] = [__v_7]; + record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29408,15 +29488,15 @@ fn aiur_fn_324( }) } -const INPUT_SIZE_325: usize = 1; -const IN_325: usize = 1; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_326: usize = 1; +const IN_326: usize = 1; +const OUT_326: usize = 1; +fn aiur_fn_326( + inp: [G; IN_326], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_325], ExecError> { +) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -29426,66 +29506,17 @@ fn aiur_fn_325( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); - let __ret: [G; OUT_325] = [__v_7]; - record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_326: usize = 2; -const IN_326: usize = 2; -const OUT_326: usize = 1; -fn aiur_fn_326( - inp: [G; IN_326], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_326], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - match __v_1.as_canonical_u64() { - 0u64 => { - let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_2]; + let __ret: [G; OUT_326] = [__v_7]; record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_3.as_canonical_u64() { - 0u64 => { - let __ret: [G; OUT_326] = [__v_2]; - record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 1u64 => { - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_326] = [__v_7]; - record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); - }, - } + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) @@ -29505,29 +29536,29 @@ fn aiur_fn_327( let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __v_2: G = G::from_u64(1); - let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_327] = [__v_4]; + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_327] = [__v_2]; record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_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_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_327] = [__v_0]; + let __ret: [G; OUT_327] = [__v_2]; record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_327] = [__v_5]; + let __v_5: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = (__v_2 + __v_6); + let __ret: [G; OUT_327] = [__v_7]; record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -29540,8 +29571,8 @@ fn aiur_fn_327( }) } -const INPUT_SIZE_328: usize = 3; -const IN_328: usize = 3; +const INPUT_SIZE_328: usize = 2; +const IN_328: usize = 2; const OUT_328: usize = 1; fn aiur_fn_328( inp: [G; IN_328], @@ -29552,33 +29583,36 @@ fn aiur_fn_328( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_328] = [__v_0]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_328] = [__v_4]; record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - match __v_4.as_canonical_u64() { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_328] = [__v_0]; record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_5]; record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, @@ -29595,6 +29629,52 @@ fn aiur_fn_329( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_329] = [__v_0]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_329] = [__v_0]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_329] = [__v_5]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_330: usize = 3; +const IN_330: usize = 3; +const OUT_330: usize = 1; +fn aiur_fn_330( + inp: [G; IN_330], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29606,90 +29686,90 @@ fn aiur_fn_329( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_329] = [__v_7]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_7]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_9]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_9]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_9]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_9]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_11]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_11]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_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_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_13]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_13]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_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_328] = { let __args: [G; IN_328] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_13]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_13]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_329] = [__v_7]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_7]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_9]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_9]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_9]; - record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_330] = [__v_9]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29699,15 +29779,15 @@ fn aiur_fn_329( }) } -const INPUT_SIZE_330: usize = 3; -const IN_330: usize = 3; -const OUT_330: usize = 1; -fn aiur_fn_330( - inp: [G; IN_330], +const INPUT_SIZE_331: usize = 3; +const IN_331: usize = 3; +const OUT_331: usize = 1; +fn aiur_fn_331( + inp: [G; IN_331], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_330], ExecError> { +) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29718,8 +29798,8 @@ fn aiur_fn_330( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_6]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_331] = [__v_6]; + record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -29727,8 +29807,8 @@ fn aiur_fn_330( let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_7]; - record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_331] = [__v_7]; + record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29738,15 +29818,15 @@ fn aiur_fn_330( }) } -const INPUT_SIZE_331: usize = 5; -const IN_331: usize = 5; -const OUT_331: usize = 1; -fn aiur_fn_331( - inp: [G; IN_331], +const INPUT_SIZE_332: usize = 5; +const IN_332: usize = 5; +const OUT_332: usize = 1; +fn aiur_fn_332( + inp: [G; IN_332], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_331], ExecError> { +) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29754,56 +29834,56 @@ fn aiur_fn_331( 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_328] = { let __args: [G; IN_328] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_331] = [__v_11]; - record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_332] = [__v_11]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_332: usize = 3; -const IN_332: usize = 3; -const OUT_332: usize = 1; -fn aiur_fn_332( - inp: [G; IN_332], +const INPUT_SIZE_333: usize = 3; +const IN_333: usize = 3; +const OUT_333: usize = 1; +fn aiur_fn_333( + inp: [G; IN_333], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_332], ExecError> { +) -> Result<[G; OUT_333], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_332] = [__v_0]; - record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_333] = [__v_0]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_332] = [__v_0]; - record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_333] = [__v_0]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_5]; - record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_333] = [__v_5]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29815,15 +29895,15 @@ fn aiur_fn_332( }) } -const INPUT_SIZE_333: usize = 3; -const IN_333: usize = 3; -const OUT_333: usize = 1; -fn aiur_fn_333( - inp: [G; IN_333], +const INPUT_SIZE_334: usize = 3; +const IN_334: usize = 3; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: [G; IN_334], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_333], ExecError> { +) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29838,8 +29918,8 @@ fn aiur_fn_333( 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_333] = [__v_0]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_0]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -29847,8 +29927,8 @@ fn aiur_fn_333( let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_11]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_11]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29860,88 +29940,88 @@ fn aiur_fn_333( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_9]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_9]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_9]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_9]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_11]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_11]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_13]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_13]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_13]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_13]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_13]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_13]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_9]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_9]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_9]; - record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_334] = [__v_9]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29951,34 +30031,34 @@ fn aiur_fn_333( }) } -const INPUT_SIZE_334: usize = 3; -const IN_334: usize = 3; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_335: usize = 3; +const IN_335: usize = 3; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: [G; IN_335], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_334] = [__v_0]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_335] = [__v_0]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_5]; - record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_335] = [__v_5]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -29988,15 +30068,15 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 3; -const IN_335: usize = 3; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_336: usize = 3; +const IN_336: usize = 3; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: [G; IN_336], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], ExecError> { +) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30008,90 +30088,90 @@ fn aiur_fn_335( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_335] = [__v_7]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_7]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_9]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_9]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_9]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_9]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_11]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_11]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_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_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_13]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_13]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_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_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_13]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_13]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_335] = [__v_7]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_7]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_9]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_9]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_9]; - record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_336] = [__v_9]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30101,28 +30181,28 @@ fn aiur_fn_335( }) } -const INPUT_SIZE_336: usize = 3; -const IN_336: usize = 3; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_337: usize = 3; +const IN_337: usize = 3; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: [G; IN_337], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_6]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_337] = [__v_6]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -30130,10 +30210,10 @@ fn aiur_fn_336( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_6]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_337] = [__v_6]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30142,8 +30222,8 @@ fn aiur_fn_336( let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_9]; - record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_337] = [__v_9]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -30155,15 +30235,15 @@ fn aiur_fn_336( }) } -const INPUT_SIZE_337: usize = 5; -const IN_337: usize = 5; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_338: usize = 5; +const IN_338: usize = 5; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], ExecError> { +) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30171,49 +30251,49 @@ fn aiur_fn_337( 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_334] = { let __args: [G; IN_334] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_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_334] = { let __args: [G; IN_334] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_11]; - record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_338] = [__v_11]; + record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_338: usize = 3; -const IN_338: usize = 3; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_339: usize = 3; +const IN_339: usize = 3; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: [G; IN_339], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_338] = [__v_0]; - record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_5]; - record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_339] = [__v_5]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30223,33 +30303,33 @@ fn aiur_fn_338( }) } -const INPUT_SIZE_339: usize = 3; -const IN_339: usize = 3; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_340: usize = 3; +const IN_340: usize = 3; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: [G; IN_340], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], ExecError> { +) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_339] = [__v_8]; - record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_340] = [__v_8]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -30257,8 +30337,8 @@ fn aiur_fn_339( let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_339] = [__v_9]; - record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_340] = [__v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30268,15 +30348,15 @@ fn aiur_fn_339( }) } -const INPUT_SIZE_340: usize = 3; -const IN_340: usize = 3; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_341: usize = 3; +const IN_341: usize = 3; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: [G; IN_341], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30288,90 +30368,90 @@ fn aiur_fn_340( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_7]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_7]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_9]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_9]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_9]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_9]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_11]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_11]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_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_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_13]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_13]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_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_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_13]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_13]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_7]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_7]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_9]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_9]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_9]; - record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_341] = [__v_9]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30381,15 +30461,15 @@ fn aiur_fn_340( }) } -const INPUT_SIZE_341: usize = 5; -const IN_341: usize = 5; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_342: usize = 5; +const IN_342: usize = 5; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: [G; IN_342], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], ExecError> { +) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30397,30 +30477,30 @@ fn aiur_fn_341( 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_338] = { let __args: [G; IN_338] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_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_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_341] = [__v_11]; - record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_342] = [__v_11]; + record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_342: usize = 3; -const IN_342: usize = 3; -const OUT_342: usize = 3; -fn aiur_fn_342( - inp: [G; IN_342], +const INPUT_SIZE_343: usize = 3; +const IN_343: usize = 3; +const OUT_343: usize = 3; +fn aiur_fn_343( + inp: [G; IN_343], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_342], ExecError> { +) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30440,17 +30520,17 @@ fn aiur_fn_342( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_342] = [__v_12, __v_13, __v_14]; - record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_343] = [__v_12, __v_13, __v_14]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_342] = [__v_0, __v_2, __v_1]; - record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_343] = [__v_0, __v_2, __v_1]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30459,23 +30539,23 @@ fn aiur_fn_342( } }, _ => { - let __ret: [G; OUT_342] = [__v_0, __v_2, __v_1]; - record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_343] = [__v_0, __v_2, __v_1]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_343: usize = 3; -const IN_343: usize = 3; -const OUT_343: usize = 1; -fn aiur_fn_343( - inp: [G; IN_343], +const INPUT_SIZE_344: usize = 3; +const IN_344: usize = 3; +const OUT_344: usize = 1; +fn aiur_fn_344( + inp: [G; IN_344], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_343], 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]; @@ -30483,56 +30563,56 @@ fn aiur_fn_343( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __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_717] = { let __args: [G; IN_717] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_10]; - record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_10]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_14]; - record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_14]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_12]; - record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_344] = [__v_12]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_344: usize = 3; -const IN_344: usize = 3; -const OUT_344: usize = 1; -fn aiur_fn_344( - inp: [G; IN_344], +const INPUT_SIZE_345: usize = 3; +const IN_345: usize = 3; +const OUT_345: usize = 1; +fn aiur_fn_345( + inp: [G; IN_345], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_344], 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]; @@ -30547,87 +30627,87 @@ fn aiur_fn_344( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_10]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_10]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_7]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_7]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_7]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_7]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_9]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_9]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_7]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_7]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_7]; - record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_345] = [__v_7]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_345: usize = 5; -const IN_345: usize = 5; -const OUT_345: usize = 1; -fn aiur_fn_345( - inp: [G; IN_345], +const INPUT_SIZE_346: usize = 5; +const IN_346: usize = 5; +const OUT_346: usize = 1; +fn aiur_fn_346( + inp: [G; IN_346], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_345], ExecError> { +) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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_383] = { let __args: [G; IN_383] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __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_344] = { let __args: [G; IN_344] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_11]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_346] = [__v_11]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30638,7 +30718,7 @@ fn aiur_fn_345( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -30656,12 +30736,12 @@ fn aiur_fn_345( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_30]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_346] = [__v_30]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -30669,8 +30749,8 @@ fn aiur_fn_345( let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_30]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_346] = [__v_30]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -30680,8 +30760,8 @@ fn aiur_fn_345( let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_17]; - record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_346] = [__v_17]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -30690,15 +30770,15 @@ fn aiur_fn_345( }) } -const INPUT_SIZE_346: usize = 0; -const IN_346: usize = 0; -const OUT_346: usize = 1; -fn aiur_fn_346( - inp: [G; IN_346], +const INPUT_SIZE_347: usize = 0; +const IN_347: usize = 0; +const OUT_347: usize = 1; +fn aiur_fn_347( + inp: [G; IN_347], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_346], ExecError> { +) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(116); let __v_1: G = G::from_u64(89); @@ -30733,21 +30813,21 @@ fn aiur_fn_346( let __v_30: G = G::from_u64(91); let __v_31: G = G::from_u64(151); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_346] = [__v_32]; - record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_347] = [__v_32]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_347: usize = 0; -const IN_347: usize = 0; -const OUT_347: usize = 1; -fn aiur_fn_347( - inp: [G; IN_347], +const INPUT_SIZE_348: usize = 0; +const IN_348: usize = 0; +const OUT_348: usize = 1; +fn aiur_fn_348( + inp: [G; IN_348], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_347], ExecError> { +) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(55); @@ -30782,21 +30862,21 @@ fn aiur_fn_347( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(25); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_347] = [__v_32]; - record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_348] = [__v_32]; + record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_348: usize = 0; -const IN_348: usize = 0; -const OUT_348: usize = 1; -fn aiur_fn_348( - inp: [G; IN_348], +const INPUT_SIZE_349: usize = 0; +const IN_349: usize = 0; +const OUT_349: usize = 1; +fn aiur_fn_349( + inp: [G; IN_349], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_348], ExecError> { +) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(57); let __v_1: G = G::from_u64(138); @@ -30831,21 +30911,21 @@ fn aiur_fn_348( let __v_30: G = G::from_u64(182); let __v_31: G = G::from_u64(49); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_348] = [__v_32]; - record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_349] = [__v_32]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_349: usize = 0; -const IN_349: usize = 0; -const OUT_349: usize = 1; -fn aiur_fn_349( - inp: [G; IN_349], +const INPUT_SIZE_350: usize = 0; +const IN_350: usize = 0; +const OUT_350: usize = 1; +fn aiur_fn_350( + inp: [G; IN_350], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_349], ExecError> { +) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(136); let __v_1: G = G::from_u64(38); @@ -30880,21 +30960,21 @@ fn aiur_fn_349( let __v_30: G = G::from_u64(236); let __v_31: G = G::from_u64(246); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_349] = [__v_32]; - record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_350] = [__v_32]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_350: usize = 0; -const IN_350: usize = 0; -const OUT_350: usize = 1; -fn aiur_fn_350( - inp: [G; IN_350], +const INPUT_SIZE_351: usize = 0; +const IN_351: usize = 0; +const OUT_351: usize = 1; +fn aiur_fn_351( + inp: [G; IN_351], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_350], ExecError> { +) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(141); let __v_1: G = G::from_u64(196); @@ -30929,21 +31009,21 @@ fn aiur_fn_350( let __v_30: G = G::from_u64(123); let __v_31: G = G::from_u64(208); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_350] = [__v_32]; - record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_351] = [__v_32]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_351: usize = 0; -const IN_351: usize = 0; -const OUT_351: usize = 1; -fn aiur_fn_351( - inp: [G; IN_351], +const INPUT_SIZE_352: usize = 0; +const IN_352: usize = 0; +const OUT_352: usize = 1; +fn aiur_fn_352( + inp: [G; IN_352], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_351], ExecError> { +) -> Result<[G; OUT_352], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(18); let __v_1: G = G::from_u64(73); @@ -30978,27 +31058,27 @@ fn aiur_fn_351( let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(22); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_351] = [__v_32]; - record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_352] = [__v_32]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_352: usize = 4; -const IN_352: usize = 4; -const OUT_352: usize = 2; -fn aiur_fn_352( - inp: [G; IN_352], +const INPUT_SIZE_353: usize = 4; +const IN_353: usize = 4; +const OUT_353: usize = 2; +fn aiur_fn_353( + inp: [G; IN_353], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_352], ExecError> { +) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -31009,8 +31089,8 @@ fn aiur_fn_352( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_6, __v_10]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_6, __v_10]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31023,7 +31103,7 @@ fn aiur_fn_352( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -31034,12 +31114,12 @@ fn aiur_fn_352( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_12, __v_16]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_12, __v_16]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -31050,25 +31130,25 @@ fn aiur_fn_352( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_15, __v_19]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_15, __v_19]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -31102,7 +31182,7 @@ fn aiur_fn_352( let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); @@ -31131,13 +31211,13 @@ fn aiur_fn_352( let __v_73: G = G::from_u64(0); let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_77, __v_78]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_77, __v_78]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31146,8 +31226,8 @@ fn aiur_fn_352( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_42, __v_46]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_42, __v_46]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31158,8 +31238,8 @@ fn aiur_fn_352( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_33, __v_37]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_33, __v_37]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31170,8 +31250,8 @@ fn aiur_fn_352( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_29, __v_33]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_29, __v_33]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31186,8 +31266,8 @@ fn aiur_fn_352( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_10, __v_14]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_10, __v_14]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31198,8 +31278,8 @@ fn aiur_fn_352( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_352] = [__v_6, __v_10]; - record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_353] = [__v_6, __v_10]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31208,15 +31288,15 @@ fn aiur_fn_352( }) } -const INPUT_SIZE_353: usize = 1; -const IN_353: usize = 1; -const OUT_353: usize = 1; -fn aiur_fn_353( - inp: [G; IN_353], +const INPUT_SIZE_354: usize = 1; +const IN_354: usize = 1; +const OUT_354: usize = 1; +fn aiur_fn_354( + inp: [G; IN_354], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_353], ExecError> { +) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -31228,8 +31308,8 @@ fn aiur_fn_353( 2u64 => { let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_5]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_354] = [__v_5]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31244,23 +31324,23 @@ fn aiur_fn_353( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_15]; - record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_354] = [__v_15]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_355: usize = 2; +const IN_355: usize = 2; +const OUT_355: usize = 1; +fn aiur_fn_355( + inp: [G; IN_355], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_354], 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]; @@ -31273,19 +31353,19 @@ fn aiur_fn_354( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_354] = [__v_7]; - record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_355] = [__v_7]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_354] = [__v_8]; - record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_355] = [__v_8]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31295,43 +31375,43 @@ fn aiur_fn_354( }) } -const INPUT_SIZE_355: usize = 3; -const IN_355: usize = 3; -const OUT_355: usize = 2; -fn aiur_fn_355( - inp: [G; IN_355], +const INPUT_SIZE_356: usize = 3; +const IN_356: usize = 3; +const OUT_356: usize = 2; +fn aiur_fn_356( + inp: [G; IN_356], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_355], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_355] = [__v_4, __v_5]; - record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_356] = [__v_4, __v_5]; + record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_356: usize = 2; -const IN_356: usize = 2; -const OUT_356: usize = 1; -fn aiur_fn_356( - inp: [G; IN_356], +const INPUT_SIZE_357: usize = 2; +const IN_357: usize = 2; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: [G; IN_357], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_356], 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 __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -31339,8 +31419,8 @@ fn aiur_fn_356( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_356] = [__v_2]; - record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_2]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -31350,26 +31430,26 @@ fn aiur_fn_356( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_356] = [__v_2]; - record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_2]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_17]; - record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_357] = [__v_17]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31384,15 +31464,15 @@ fn aiur_fn_356( }) } -const INPUT_SIZE_357: usize = 1; -const IN_357: usize = 1; -const OUT_357: usize = 1; -fn aiur_fn_357( - inp: [G; IN_357], +const INPUT_SIZE_358: usize = 1; +const IN_358: usize = 1; +const OUT_358: usize = 1; +fn aiur_fn_358( + inp: [G; IN_358], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_357], ExecError> { +) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; @@ -31400,8 +31480,8 @@ fn aiur_fn_357( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_357] = [__v_2]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_2]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31410,8 +31490,8 @@ fn aiur_fn_357( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(2); - let __ret: [G; OUT_357] = [__v_3]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_3]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31420,8 +31500,8 @@ fn aiur_fn_357( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(3); - let __ret: [G; OUT_357] = [__v_4]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_4]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31430,24 +31510,24 @@ fn aiur_fn_357( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(4); - let __ret: [G; OUT_357] = [__v_5]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_5]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(5); - let __ret: [G; OUT_357] = [__v_6]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_6]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_357] = [__v_6]; - record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_358] = [__v_6]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31462,63 +31542,63 @@ fn aiur_fn_357( }) } -const INPUT_SIZE_358: usize = 4; -const IN_358: usize = 4; -const OUT_358: usize = 2; -fn aiur_fn_358( - inp: [G; IN_358], +const INPUT_SIZE_359: usize = 4; +const IN_359: usize = 4; +const OUT_359: usize = 2; +fn aiur_fn_359( + inp: [G; IN_359], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_358], 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_357] = { let __args: [G; IN_357] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_358] = [__v_5, __v_6]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_5, __v_6]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_358] = [__v_6, __v_7]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_6, __v_7]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_358] = [__v_5, __v_6]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_5, __v_6]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_358] = [__v_5, __v_6]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_5, __v_6]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_358] = [__v_5, __v_6]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_5, __v_6]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31527,52 +31607,52 @@ fn aiur_fn_358( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_358] = [__v_5, __v_9]; - record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_359] = [__v_5, __v_9]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_359: usize = 3; -const IN_359: usize = 3; -const OUT_359: usize = 2; -fn aiur_fn_359( - inp: [G; IN_359], +const INPUT_SIZE_360: usize = 3; +const IN_360: usize = 3; +const OUT_360: usize = 2; +fn aiur_fn_360( + inp: [G; IN_360], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_359], 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]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_359] = [__v_5, __v_6]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_360] = [__v_5, __v_6]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_359] = [__v_7, __v_8]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_360] = [__v_7, __v_8]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31581,75 +31661,7 @@ fn aiur_fn_359( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_7, __v_11]; - record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }, - } - }) -} - -const INPUT_SIZE_360: usize = 2; -const IN_360: usize = 2; -const OUT_360: usize = 2; -fn aiur_fn_360( - inp: [G; IN_360], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> 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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __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 }; - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_5, __v_9]; - record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; - let __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_728] = { let __args: [G; IN_728] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - let __v_13: G = G::from_u64(1); - let __v_14: G = G::from_u64(3); - let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_360] = [__v_13, __v_17]; - record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_11, __v_15]; + let __ret: [G; OUT_360] = [__v_7, __v_11]; record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -31671,9 +31683,9 @@ fn aiur_fn_361( 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_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __v_3: G = G::from_u64(5); + 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 }; match __v_4.as_canonical_u64() { 1u64 => { @@ -31688,18 +31700,18 @@ fn aiur_fn_361( }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __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_728] = { let __args: [G; IN_728] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __v_11: G = G::from_u64(6); + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); @@ -31739,7 +31751,75 @@ fn aiur_fn_362( 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_383] = { let __args: [G; IN_383] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __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 }; + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_362] = [__v_5, __v_9]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(3); + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __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_729] = { let __args: [G; IN_729] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(3); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_362] = [__v_13, __v_17]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_362] = [__v_11, __v_15]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_363: usize = 2; +const IN_363: usize = 2; +const OUT_363: usize = 2; +fn aiur_fn_363( + inp: [G; IN_363], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -31751,13 +31831,13 @@ fn aiur_fn_362( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -31765,10 +31845,10 @@ fn aiur_fn_362( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_362] = [__v_14, __v_16]; - record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_14, __v_16]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31777,8 +31857,8 @@ fn aiur_fn_362( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_362] = [__v_14, __v_18]; - record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_14, __v_18]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31789,8 +31869,8 @@ fn aiur_fn_362( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_362] = [__v_11, __v_15]; - record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_11, __v_15]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31801,43 +31881,43 @@ fn aiur_fn_362( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_362] = [__v_9, __v_13]; - record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_363] = [__v_9, __v_13]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_363: usize = 5; -const IN_363: usize = 5; -const OUT_363: usize = 1; -fn aiur_fn_363( - inp: [G; IN_363], +const INPUT_SIZE_364: usize = 5; +const IN_364: usize = 5; +const OUT_364: usize = 1; +fn aiur_fn_364( + inp: [G; IN_364], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_363], 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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __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_383] = { let __args: [G; IN_383] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_7]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_7]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_363] = [__v_6]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_6]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -31858,24 +31938,24 @@ fn aiur_fn_363( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __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_383] = { let __args: [G; IN_383] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_22]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_22]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_23]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_23]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31883,43 +31963,43 @@ fn aiur_fn_363( 2u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_20]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_20]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __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_383] = { let __args: [G; IN_383] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_22]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_22]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_22]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_22]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 7u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __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_383] = { let __args: [G; IN_383] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_23]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_23]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { @@ -31928,30 +32008,30 @@ fn aiur_fn_363( let __v_23: G = (__v_11 + __v_13); let __v_24: G = (__v_23 + __v_14); let __v_25: G = (__v_24 + __v_12); - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_10, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_22, __v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_22, __v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_28]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_28]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_25]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_25]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_363] = [__v_22]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_22]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31961,8 +32041,8 @@ fn aiur_fn_363( _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_23]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_23]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31970,8 +32050,8 @@ fn aiur_fn_363( _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_20]; - record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_364] = [__v_20]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -31980,20 +32060,20 @@ fn aiur_fn_363( }) } -const INPUT_SIZE_364: usize = 2; -const IN_364: usize = 2; -const OUT_364: usize = 2; -fn aiur_fn_364( - inp: [G; IN_364], +const INPUT_SIZE_365: usize = 2; +const IN_365: usize = 2; +const OUT_365: usize = 2; +fn aiur_fn_365( + inp: [G; IN_365], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_364], 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 = G::from_u64(0); - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -32001,7 +32081,7 @@ fn aiur_fn_364( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { @@ -32011,22 +32091,22 @@ fn aiur_fn_364( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_10, __v_14]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_10, __v_14]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_14, __v_15]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_14, __v_15]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32037,23 +32117,23 @@ fn aiur_fn_364( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_8, __v_12]; - record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_365] = [__v_8, __v_12]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_365: usize = 2; -const IN_365: usize = 2; -const OUT_365: usize = 5; -fn aiur_fn_365( - inp: [G; IN_365], +const INPUT_SIZE_366: usize = 2; +const IN_366: usize = 2; +const OUT_366: usize = 5; +fn aiur_fn_366( + inp: [G; IN_366], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_365], 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]; @@ -32066,14 +32146,14 @@ fn aiur_fn_365( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __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_365] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_366] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { @@ -32091,8 +32171,8 @@ fn aiur_fn_365( 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_365] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_366] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -32133,8 +32213,8 @@ fn aiur_fn_365( let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __ret: [G; OUT_365] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_366] = [__v_11, __v_12, __v_45, __v_46, __v_47]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32177,8 +32257,8 @@ fn aiur_fn_365( let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_365] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_366] = [__v_10, __v_11, __v_44, __v_45, __v_46]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32221,23 +32301,23 @@ fn aiur_fn_365( let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_365] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_366] = [__v_6, __v_7, __v_40, __v_41, __v_42]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_366: usize = 1; -const IN_366: usize = 1; -const OUT_366: usize = 1; -fn aiur_fn_366( - inp: [G; IN_366], +const INPUT_SIZE_367: usize = 1; +const IN_367: usize = 1; +const OUT_367: usize = 1; +fn aiur_fn_367( + inp: [G; IN_367], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_366], ExecError> { +) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -32261,8 +32341,8 @@ fn aiur_fn_366( let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_366] = [__v_12]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_367] = [__v_12]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -32285,37 +32365,37 @@ fn aiur_fn_366( let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_366] = [__v_21]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_367] = [__v_21]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_366] = [__v_0]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_367] = [__v_0]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_366] = [__v_0]; - record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_367] = [__v_0]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_367: usize = 10; -const IN_367: usize = 10; -const OUT_367: usize = 1; -fn aiur_fn_367( - inp: [G; IN_367], +const INPUT_SIZE_368: usize = 10; +const IN_368: usize = 10; +const OUT_368: usize = 1; +fn aiur_fn_368( + inp: [G; IN_368], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_367], 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]; @@ -32340,35 +32420,35 @@ fn aiur_fn_367( let __v_15: G = (__v_4 + __v_5); let __v_16: G = (__v_3 + __v_15); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_18, __v_11, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_18, __v_11, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_367] = [__v_7]; - record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_368] = [__v_7]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_3 + __v_4); let __v_22: G = (__v_2 + __v_21); - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_17 + __v_24); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_27, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_367] = [__v_29]; - record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_368] = [__v_29]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32376,32 +32456,32 @@ fn aiur_fn_367( } }, _ => { - let __ret: [G; OUT_367] = [__v_7]; - record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_368] = [__v_7]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_368: usize = 5; -const IN_368: usize = 5; -const OUT_368: usize = 1; -fn aiur_fn_368( - inp: [G; IN_368], +const INPUT_SIZE_369: usize = 5; +const IN_369: usize = 5; +const OUT_369: usize = 1; +fn aiur_fn_369( + inp: [G; IN_369], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_368], 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 __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -32418,8 +32498,8 @@ fn aiur_fn_368( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_368] = [__v_14]; - record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_369] = [__v_14]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -32440,27 +32520,27 @@ fn aiur_fn_368( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_34]; - record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_369] = [__v_34]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_368] = [__v_27]; - record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_369] = [__v_27]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32469,57 +32549,57 @@ fn aiur_fn_368( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_368] = [__v_13]; - record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_369] = [__v_13]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_370: usize = 3; +const IN_370: usize = 3; +const OUT_370: usize = 1; +fn aiur_fn_370( + inp: [G; IN_370], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_369], 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 __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __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_728] = { let __args: [G; IN_728] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_13]; - record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_370] = [__v_13]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_370: usize = 10; -const IN_370: usize = 10; -const OUT_370: usize = 2; -fn aiur_fn_370( - inp: [G; IN_370], +const INPUT_SIZE_371: usize = 10; +const IN_371: usize = 10; +const OUT_371: usize = 2; +fn aiur_fn_371( + inp: [G; IN_371], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_370], 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]; @@ -32534,7 +32614,7 @@ fn aiur_fn_370( 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_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_14.as_canonical_u64() { @@ -32544,8 +32624,8 @@ fn aiur_fn_370( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_15, __v_19]; - record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_371] = [__v_15, __v_19]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -32555,29 +32635,29 @@ fn aiur_fn_370( match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_370] = [__v_17, __v_16]; - record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_371] = [__v_17, __v_16]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_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_372] = { let __args: [G; IN_372] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -32589,30 +32669,30 @@ fn aiur_fn_370( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_370] = [__v_32, __v_33]; - record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_371] = [__v_32, __v_33]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_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_727] = { let __args: [G; IN_727] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __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_728] = { let __args: [G; IN_728] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; @@ -32621,8 +32701,8 @@ fn aiur_fn_370( let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); - let __ret: [G; OUT_370] = [__v_44, __v_43]; - record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_371] = [__v_44, __v_43]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -32631,13 +32711,13 @@ fn aiur_fn_370( } }, _ => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_370] = [__v_27, __v_28]; - record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_371] = [__v_27, __v_28]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32648,15 +32728,15 @@ fn aiur_fn_370( }) } -const INPUT_SIZE_371: usize = 1; -const IN_371: usize = 1; -const OUT_371: usize = 4; -fn aiur_fn_371( - inp: [G; IN_371], +const INPUT_SIZE_372: usize = 1; +const IN_372: usize = 1; +const OUT_372: usize = 4; +fn aiur_fn_372( + inp: [G; IN_372], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_371], ExecError> { +) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -32687,10 +32767,10 @@ fn aiur_fn_371( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_20, __v_13, __v_21, __v_2]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_372] = [__v_20, __v_13, __v_21, __v_2]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -32732,8 +32812,8 @@ fn aiur_fn_371( let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_371] = [__v_20, __v_21, __v_54, __v_57]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_372] = [__v_20, __v_21, __v_54, __v_57]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32777,23 +32857,23 @@ fn aiur_fn_371( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_371] = [__v_7, __v_8, __v_41, __v_44]; - record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_372] = [__v_7, __v_8, __v_41, __v_44]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_372: usize = 2; -const IN_372: usize = 2; -const OUT_372: usize = 3; -fn aiur_fn_372( - inp: [G; IN_372], +const INPUT_SIZE_373: usize = 2; +const IN_373: usize = 2; +const OUT_373: usize = 3; +fn aiur_fn_373( + inp: [G; IN_373], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_372], 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]; @@ -32811,8 +32891,8 @@ fn aiur_fn_372( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_372] = [__v_7, __v_8, __v_12]; - record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_373] = [__v_7, __v_8, __v_12]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -32822,17 +32902,17 @@ fn aiur_fn_372( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_372] = [__v_8, __v_4, __v_5]; - record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_373] = [__v_8, __v_4, __v_5]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __ret: [G; OUT_372] = [__v_8, __v_9, __v_10]; - record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_373] = [__v_8, __v_9, __v_10]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -32846,15 +32926,15 @@ fn aiur_fn_372( }) } -const INPUT_SIZE_373: usize = 9; -const IN_373: usize = 9; -const OUT_373: usize = 2; -fn aiur_fn_373( - inp: [G; IN_373], +const INPUT_SIZE_374: usize = 9; +const IN_374: usize = 9; +const OUT_374: usize = 2; +fn aiur_fn_374( + inp: [G; IN_374], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_373], ExecError> { +) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32878,8 +32958,8 @@ fn aiur_fn_373( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_14, __v_18]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_14, __v_18]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -32896,8 +32976,8 @@ fn aiur_fn_373( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_19, __v_23]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_19, __v_23]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -32906,7 +32986,7 @@ fn aiur_fn_373( 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_374] = { let __args: [G; IN_374] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -32916,8 +32996,8 @@ fn aiur_fn_373( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_24, __v_28]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_24, __v_28]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -32944,7 +33024,7 @@ fn aiur_fn_373( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -32953,16 +33033,16 @@ fn aiur_fn_373( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_40, __v_44]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_40, __v_44]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_41, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_41, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; match __v_42.as_canonical_u64() { 1u64 => { @@ -32971,31 +33051,31 @@ fn aiur_fn_373( 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_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_43, __v_47]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_43, __v_47]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = (__v_3 + __v_4); let __v_45: G = (__v_44 + __v_5); - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_43, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_47, __v_23, __v_40, __v_11, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_47, __v_23, __v_40, __v_11, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_21 + __v_50); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_53, __v_54]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_53, __v_54]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33008,8 +33088,8 @@ fn aiur_fn_373( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_39, __v_43]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_39, __v_43]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33020,8 +33100,8 @@ fn aiur_fn_373( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_39, __v_43]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_39, __v_43]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33032,8 +33112,8 @@ fn aiur_fn_373( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_37, __v_41]; - record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_374] = [__v_37, __v_41]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33054,15 +33134,15 @@ fn aiur_fn_373( }) } -const INPUT_SIZE_374: usize = 2; -const IN_374: usize = 2; -const OUT_374: usize = 2; -fn aiur_fn_374( - inp: [G; IN_374], +const INPUT_SIZE_375: usize = 2; +const IN_375: usize = 2; +const OUT_375: usize = 2; +fn aiur_fn_375( + inp: [G; IN_375], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_374], ExecError> { +) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33086,8 +33166,8 @@ fn aiur_fn_374( match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_374] = [__v_12, __v_9]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_375] = [__v_12, __v_9]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -33125,8 +33205,8 @@ fn aiur_fn_374( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_12, __v_45]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_375] = [__v_12, __v_45]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33166,8 +33246,8 @@ fn aiur_fn_374( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_6, __v_39]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_375] = [__v_6, __v_39]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33182,11 +33262,11 @@ fn aiur_fn_374( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_374] = [__v_8, __v_9]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_375] = [__v_8, __v_9]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -33224,8 +33304,8 @@ fn aiur_fn_374( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_6, __v_39]; - record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_375] = [__v_6, __v_39]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33234,15 +33314,15 @@ fn aiur_fn_374( }) } -const INPUT_SIZE_375: usize = 5; -const IN_375: usize = 5; -const OUT_375: usize = 1; -fn aiur_fn_375( - inp: [G; IN_375], +const INPUT_SIZE_376: usize = 5; +const IN_376: usize = 5; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: [G; IN_376], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_375], 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]; @@ -33252,8 +33332,8 @@ fn aiur_fn_375( let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_375] = [__v_0]; - record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_376] = [__v_0]; + record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -33264,25 +33344,25 @@ fn aiur_fn_375( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_375] = [__v_13]; - record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_376] = [__v_13]; + record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_376: usize = 1; -const IN_376: usize = 1; -const OUT_376: usize = 1; -fn aiur_fn_376( - inp: [G; IN_376], +const INPUT_SIZE_377: usize = 1; +const IN_377: usize = 1; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_376], ExecError> { +) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; @@ -33302,34 +33382,34 @@ fn aiur_fn_376( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_16]; - record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_377] = [__v_16]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_376] = [__v_14]; - record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_377] = [__v_14]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_377: usize = 2; -const IN_377: usize = 2; -const OUT_377: usize = 1; -fn aiur_fn_377( - inp: [G; IN_377], +const INPUT_SIZE_378: usize = 2; +const IN_378: usize = 2; +const OUT_378: usize = 1; +fn aiur_fn_378( + inp: [G; IN_378], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_377], ExecError> { +) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33388,8 +33468,8 @@ fn aiur_fn_377( 8u64 => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_50]; - record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_378] = [__v_50]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -33398,8 +33478,8 @@ fn aiur_fn_377( let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_377] = [__v_54]; - record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_378] = [__v_54]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33408,15 +33488,15 @@ fn aiur_fn_377( }) } -const INPUT_SIZE_378: usize = 6; -const IN_378: usize = 6; -const OUT_378: usize = 1; -fn aiur_fn_378( - inp: [G; IN_378], +const INPUT_SIZE_379: usize = 6; +const IN_379: usize = 6; +const OUT_379: usize = 1; +fn aiur_fn_379( + inp: [G; IN_379], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_378], 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]; @@ -33428,8 +33508,8 @@ fn aiur_fn_378( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_378] = [__v_7]; - record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_379] = [__v_7]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -33450,32 +33530,32 @@ fn aiur_fn_378( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_378] = [__v_22]; - record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_379] = [__v_22]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!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_378] = { let __args: [G; IN_378] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_24]; - record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_379] = [__v_24]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_378] = [__v_20]; - record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_379] = [__v_20]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33484,22 +33564,22 @@ fn aiur_fn_378( }) } -const INPUT_SIZE_379: usize = 2; -const IN_379: usize = 2; -const OUT_379: usize = 1; -fn aiur_fn_379( - inp: [G; IN_379], +const INPUT_SIZE_380: usize = 2; +const IN_380: usize = 2; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_379], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_379] = [__v_0]; - record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_380] = [__v_0]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -33512,66 +33592,19 @@ fn aiur_fn_379( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_379] = [__v_8]; - record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __ret: [G; OUT_379] = [__v_0]; - record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }, - } - }) -} - -const INPUT_SIZE_380: usize = 2; -const IN_380: usize = 2; -const OUT_380: usize = 1; -fn aiur_fn_380( - inp: [G; IN_380], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - let __v_5: G = __loaded[3]; - match __v_2.as_canonical_u64() { - 5u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - match __v_6.as_canonical_u64() { - 1u64 => { - let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_380] = [__v_7]; + let __ret: [G; OUT_380] = [__v_8]; record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_380] = [__v_7]; + let __ret: [G; OUT_380] = [__v_0]; record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, - _ => { - let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_380] = [__v_6]; - record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, } }) } @@ -33594,95 +33627,142 @@ fn aiur_fn_381( let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { - 2u64 => { + 5u64 => { let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __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_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); let __ret: [G; OUT_381] = [__v_6]; record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, + } + }) +} + +const INPUT_SIZE_382: usize = 2; +const IN_382: usize = 2; +const OUT_382: usize = 1; +fn aiur_fn_382( + inp: [G; IN_382], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_382] = [__v_6]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, 3u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __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_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_7]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_7]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __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_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_7]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_7]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __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_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_7]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_7]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __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_381] = [__v_7]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_7]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __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_381] = [__v_8]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_8]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_381] = [__v_8]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_8]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33690,31 +33770,31 @@ fn aiur_fn_381( } }, 8u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_381] = [__v_6]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_6]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_381] = [__v_6]; - record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_382] = [__v_6]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_382: usize = 2; -const IN_382: usize = 2; -const OUT_382: usize = 1; -fn aiur_fn_382( - inp: [G; IN_382], +const INPUT_SIZE_383: usize = 2; +const IN_383: usize = 2; +const OUT_383: usize = 1; +fn aiur_fn_383( + inp: [G; IN_383], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_382], 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]; @@ -33725,8 +33805,8 @@ fn aiur_fn_382( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_382] = [__v_5]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_383] = [__v_5]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -33735,15 +33815,15 @@ fn aiur_fn_382( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_382] = [__v_6]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_383] = [__v_6]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_6]; - record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_383] = [__v_6]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -33755,15 +33835,15 @@ fn aiur_fn_382( }) } -const INPUT_SIZE_383: usize = 2; -const IN_383: usize = 2; -const OUT_383: usize = 1; -fn aiur_fn_383( - inp: [G; IN_383], +const INPUT_SIZE_384: usize = 2; +const IN_384: usize = 2; +const OUT_384: usize = 1; +fn aiur_fn_384( + inp: [G; IN_384], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_383], 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]; @@ -33774,77 +33854,77 @@ fn aiur_fn_383( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_383] = [__v_0]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_384] = [__v_0]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_383] = [__v_0]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_384] = [__v_0]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_383] = [__v_0]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_384] = [__v_0]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_383] = [__v_0]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_384] = [__v_0]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_383] = [__v_0]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_384] = [__v_0]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_383] = [__v_8]; - record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_384] = [__v_8]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_384: usize = 2; -const IN_384: usize = 2; -const OUT_384: usize = 1; -fn aiur_fn_384( - inp: [G; IN_384], +const INPUT_SIZE_385: usize = 2; +const IN_385: usize = 2; +const OUT_385: usize = 1; +fn aiur_fn_385( + inp: [G; IN_385], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_384], ExecError> { +) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_384] = [__v_5]; - record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_385: usize = 2; -const IN_385: usize = 2; -const OUT_385: usize = 1; -fn aiur_fn_385( - inp: [G; IN_385], +const INPUT_SIZE_386: usize = 2; +const IN_386: usize = 2; +const OUT_386: usize = 1; +fn aiur_fn_386( + inp: [G; IN_386], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_385], ExecError> { +) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33855,77 +33935,77 @@ fn aiur_fn_385( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_385] = [__v_0]; - record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_386] = [__v_0]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_385] = [__v_0]; - record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_386] = [__v_0]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_385] = [__v_0]; - record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_386] = [__v_0]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_385] = [__v_0]; - record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_386] = [__v_0]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_385] = [__v_0]; - record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_386] = [__v_0]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_385] = [__v_8]; - record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_386] = [__v_8]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_386: usize = 2; -const IN_386: usize = 2; -const OUT_386: usize = 1; -fn aiur_fn_386( - inp: [G; IN_386], +const INPUT_SIZE_387: usize = 2; +const IN_387: usize = 2; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_386], ExecError> { +) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_386] = [__v_5]; - record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_387] = [__v_5]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_387: usize = 3; -const IN_387: usize = 3; -const OUT_387: usize = 1; -fn aiur_fn_387( - inp: [G; IN_387], +const INPUT_SIZE_388: usize = 3; +const IN_388: usize = 3; +const OUT_388: usize = 1; +fn aiur_fn_388( + inp: [G; IN_388], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_387], ExecError> { +) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33940,65 +34020,65 @@ fn aiur_fn_387( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_10]; - record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_10]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_7]; - record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_7]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_7]; - record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_7]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_9]; - record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_9]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_7]; - record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_7]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_7]; - record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_388] = [__v_7]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_388: usize = 3; -const IN_388: usize = 3; -const OUT_388: usize = 1; -fn aiur_fn_388( - inp: [G; IN_388], +const INPUT_SIZE_389: usize = 3; +const IN_389: usize = 3; +const OUT_389: usize = 1; +fn aiur_fn_389( + inp: [G; IN_389], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_388], ExecError> { +) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34006,78 +34086,78 @@ fn aiur_fn_388( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __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_717] = { let __args: [G; IN_717] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_10]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_389] = [__v_10]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_14]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_389] = [__v_14]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_12]; - record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_389] = [__v_12]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_389: usize = 5; -const IN_389: usize = 5; -const OUT_389: usize = 1; -fn aiur_fn_389( - inp: [G; IN_389], +const INPUT_SIZE_390: usize = 5; +const IN_390: usize = 5; +const OUT_390: usize = 1; +fn aiur_fn_390( + inp: [G; IN_390], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_389], ExecError> { +) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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_385] = { let __args: [G; IN_385] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __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_387] = { let __args: [G; IN_387] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_11]; - record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_11]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34088,7 +34168,7 @@ fn aiur_fn_389( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -34106,12 +34186,12 @@ fn aiur_fn_389( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_30]; - record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_30]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34119,8 +34199,8 @@ fn aiur_fn_389( let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_30]; - record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_30]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -34130,8 +34210,8 @@ fn aiur_fn_389( let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_17]; - record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_390] = [__v_17]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -34140,35 +34220,35 @@ fn aiur_fn_389( }) } -const INPUT_SIZE_390: usize = 5; -const IN_390: usize = 5; -const OUT_390: usize = 1; -fn aiur_fn_390( - inp: [G; IN_390], +const INPUT_SIZE_391: usize = 5; +const IN_391: usize = 5; +const OUT_391: usize = 1; +fn aiur_fn_391( + inp: [G; IN_391], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_390], 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 __v_4: G = inp[4]; - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __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_385] = { let __args: [G; IN_385] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_7]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_7]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_390] = [__v_6]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_6]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34189,66 +34269,66 @@ fn aiur_fn_390( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __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_385] = { let __args: [G; IN_385] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_22]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_22]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_22]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_22]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __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_385] = { let __args: [G; IN_385] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_22]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_22]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_22]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_22]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 7u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __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_385] = { let __args: [G; IN_385] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_23]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_23]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_23]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_23]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -34256,8 +34336,8 @@ fn aiur_fn_390( _ => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_20]; - record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_391] = [__v_20]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -34266,101 +34346,31 @@ fn aiur_fn_390( }) } -const INPUT_SIZE_391: usize = 2; -const IN_391: usize = 2; -const OUT_391: usize = 1; -fn aiur_fn_391( - inp: [G; IN_391], +const INPUT_SIZE_392: usize = 2; +const IN_392: usize = 2; +const OUT_392: usize = 1; +fn aiur_fn_392( + inp: [G; IN_392], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_391], ExecError> { +) -> Result<[G; OUT_392], 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_719] = { let __args: [G; IN_719] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __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_328] = { let __args: [G; IN_328] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_6]; - record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_392] = [__v_6]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_392: usize = 12; -const IN_392: usize = 12; -const OUT_392: usize = 1; -fn aiur_fn_392( - inp: [G; IN_392], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_392], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - match __v_0.as_canonical_u64() { - 0u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 1u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 2u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 3u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 4u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 5u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 6u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 7u64 => { - let __ret: [G; OUT_392] = [__v_1]; - record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); - }, - } - }) -} - const INPUT_SIZE_393: usize = 12; const IN_393: usize = 12; const OUT_393: usize = 1; @@ -34385,42 +34395,42 @@ fn aiur_fn_393( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_393] = [__v_2]; + let __ret: [G; OUT_393] = [__v_1]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -34431,8 +34441,8 @@ fn aiur_fn_393( }) } -const INPUT_SIZE_394: usize = 2; -const IN_394: usize = 2; +const INPUT_SIZE_394: usize = 12; +const IN_394: usize = 12; const OUT_394: usize = 1; fn aiur_fn_394( inp: [G; IN_394], @@ -34443,15 +34453,61 @@ fn aiur_fn_394( 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; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_394] = [__v_4]; - record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_394] = [__v_2]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } }) } @@ -34464,6 +34520,30 @@ fn aiur_fn_395( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_395] = [__v_4]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_396: usize = 2; +const IN_396: usize = 2; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: [G; IN_396], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34474,10 +34554,10 @@ fn aiur_fn_395( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_6]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_6]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -34485,12 +34565,12 @@ fn aiur_fn_395( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_12]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_12]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { @@ -34509,23 +34589,23 @@ fn aiur_fn_395( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_309] = { let __args: [G; IN_309] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_22]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_22]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -34535,14 +34615,14 @@ fn aiur_fn_395( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_12]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_12]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -34552,10 +34632,10 @@ fn aiur_fn_395( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_17]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_17]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34568,54 +34648,54 @@ fn aiur_fn_395( 4u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_11]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_11]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_13]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_13]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_8]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_8]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!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_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_12]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_12]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -34627,8 +34707,8 @@ fn aiur_fn_395( let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_12]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_12]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34637,9 +34717,9 @@ fn aiur_fn_395( } }, 8u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -34693,15 +34773,15 @@ fn aiur_fn_395( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_45]; - record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_396] = [__v_45]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34726,19 +34806,19 @@ fn aiur_fn_395( }) } -const INPUT_SIZE_396: usize = 2; -const IN_396: usize = 2; -const OUT_396: usize = 1; -fn aiur_fn_396( - inp: [G; IN_396], +const INPUT_SIZE_397: usize = 2; +const IN_397: usize = 2; +const OUT_397: usize = 1; +fn aiur_fn_397( + inp: [G; IN_397], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_396], 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 __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -34747,12 +34827,12 @@ fn aiur_fn_396( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_396] = [__v_4]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_397] = [__v_4]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -34761,8 +34841,8 @@ fn aiur_fn_396( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_396] = [__v_9]; - record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34774,23 +34854,23 @@ fn aiur_fn_396( }) } -const INPUT_SIZE_397: usize = 3; -const IN_397: usize = 3; -const OUT_397: usize = 1; -fn aiur_fn_397( - inp: [G; IN_397], +const INPUT_SIZE_398: usize = 3; +const IN_398: usize = 3; +const OUT_398: usize = 1; +fn aiur_fn_398( + inp: [G; IN_398], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_397], 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]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_397] = [__v_0]; - record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_398] = [__v_0]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34808,14 +34888,14 @@ fn aiur_fn_397( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_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_397] = { let __args: [G; IN_397] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_14]; - record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_398] = [__v_14]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -34832,15 +34912,15 @@ fn aiur_fn_397( }) } -const INPUT_SIZE_398: usize = 5; -const IN_398: usize = 5; -const OUT_398: usize = 1; -fn aiur_fn_398( - inp: [G; IN_398], +const INPUT_SIZE_399: usize = 5; +const IN_399: usize = 5; +const OUT_399: usize = 1; +fn aiur_fn_399( + inp: [G; IN_399], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_398], 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]; @@ -34857,22 +34937,22 @@ fn aiur_fn_398( let __v_9: G = (__v_1 - __v_2); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_398] = [__v_6]; - record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_399] = [__v_6]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_2 + __v_14); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_398] = [__v_16]; - record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_399] = [__v_16]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -34884,15 +34964,15 @@ fn aiur_fn_398( }) } -const INPUT_SIZE_399: usize = 2; -const IN_399: usize = 2; -const OUT_399: usize = 1; -fn aiur_fn_399( - inp: [G; IN_399], +const INPUT_SIZE_400: usize = 2; +const IN_400: usize = 2; +const OUT_400: usize = 1; +fn aiur_fn_400( + inp: [G; IN_400], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_399], 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]; @@ -34909,14 +34989,14 @@ fn aiur_fn_399( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_399] = [__v_8]; - record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_400] = [__v_8]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_399] = [__v_8]; - record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_400] = [__v_8]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -34929,25 +35009,25 @@ fn aiur_fn_399( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_399] = [__v_8]; - record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_400] = [__v_8]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_399] = [__v_9]; - record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_399] = [__v_9]; - record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -34964,15 +35044,15 @@ fn aiur_fn_399( }) } -const INPUT_SIZE_400: usize = 3; -const IN_400: usize = 3; -const OUT_400: usize = 1; -fn aiur_fn_400( - inp: [G; IN_400], +const INPUT_SIZE_401: usize = 3; +const IN_401: usize = 3; +const OUT_401: usize = 1; +fn aiur_fn_401( + inp: [G; IN_401], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_400], 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]; @@ -34981,38 +35061,38 @@ fn aiur_fn_400( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_400] = [__v_4]; - record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_401] = [__v_4]; + record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_400] = [__v_8]; - record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_401] = [__v_8]; + record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_401: usize = 3; -const IN_401: usize = 3; -const OUT_401: usize = 1; -fn aiur_fn_401( - inp: [G; IN_401], +const INPUT_SIZE_402: usize = 3; +const IN_402: usize = 3; +const OUT_402: usize = 1; +fn aiur_fn_402( + inp: [G; IN_402], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_401], 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]; @@ -35020,65 +35100,65 @@ fn aiur_fn_401( 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_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_4]; - record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_402] = [__v_4]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_4]; - record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_402] = [__v_4]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!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_403: usize = 3; +const IN_403: usize = 3; +const OUT_403: usize = 1; +fn aiur_fn_403( + inp: [G; IN_403], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_402], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __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_402] = [__v_4]; - record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_4]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_4]; - record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_403] = [__v_4]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_403: usize = 3; -const IN_403: usize = 3; -const OUT_403: usize = 1; -fn aiur_fn_403( - inp: [G; IN_403], +const INPUT_SIZE_404: usize = 3; +const IN_404: usize = 3; +const OUT_404: usize = 1; +fn aiur_fn_404( + inp: [G; IN_404], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_403], 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]; @@ -35106,33 +35186,33 @@ fn aiur_fn_403( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_403] = [__v_17]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_17]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_404] = { let __args: [G; IN_404] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_20]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_20]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_403] = [__v_20]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_20]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35141,39 +35221,39 @@ fn aiur_fn_403( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_403] = [__v_16]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_16]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_403] = [__v_15]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_15]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_403] = [__v_11]; - record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_404] = [__v_11]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_404: usize = 3; -const IN_404: usize = 3; -const OUT_404: usize = 1; -fn aiur_fn_404( - inp: [G; IN_404], +const INPUT_SIZE_405: usize = 3; +const IN_405: usize = 3; +const OUT_405: usize = 1; +fn aiur_fn_405( + inp: [G; IN_405], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_404], ExecError> { +) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35191,14 +35271,14 @@ fn aiur_fn_404( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_404] = [__v_9]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_9]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_404] = [__v_9]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_9]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35211,25 +35291,25 @@ fn aiur_fn_404( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_404] = [__v_9]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_9]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_404] = [__v_10]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_10]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_10]; - record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_405] = [__v_10]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35246,15 +35326,15 @@ fn aiur_fn_404( }) } -const INPUT_SIZE_405: usize = 1; -const IN_405: usize = 1; -const OUT_405: usize = 1; -fn aiur_fn_405( - inp: [G; IN_405], +const INPUT_SIZE_406: usize = 1; +const IN_406: usize = 1; +const OUT_406: usize = 1; +fn aiur_fn_406( + inp: [G; IN_406], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_405], ExecError> { +) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35268,14 +35348,14 @@ fn aiur_fn_405( 0u64 => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_5]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_5]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_405] = [__v_5]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_5]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35285,29 +35365,29 @@ fn aiur_fn_405( let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_6]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_6]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_405] = [__v_5]; - record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_406] = [__v_5]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_406: usize = 1; -const IN_406: usize = 1; -const OUT_406: usize = 3; -fn aiur_fn_406( - inp: [G; IN_406], +const INPUT_SIZE_407: usize = 1; +const IN_407: usize = 1; +const OUT_407: usize = 3; +fn aiur_fn_407( + inp: [G; IN_407], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_406], ExecError> { +) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35325,8 +35405,8 @@ fn aiur_fn_406( let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_406] = [__v_5, __v_9, __v_3]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_5, __v_9, __v_3]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -35334,8 +35414,8 @@ fn aiur_fn_406( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_5, __v_0, __v_8]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_5, __v_0, __v_8]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35354,15 +35434,15 @@ fn aiur_fn_406( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __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_108] = { let __args: [G; IN_108] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_406] = [__v_14, __v_12, __v_15]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_14, __v_12, __v_15]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -35370,8 +35450,8 @@ fn aiur_fn_406( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_11, __v_0, __v_14]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_11, __v_0, __v_14]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35399,7 +35479,7 @@ fn aiur_fn_406( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -35408,14 +35488,14 @@ fn aiur_fn_406( let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_406] = [__v_22, __v_20, __v_23]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_22, __v_20, __v_23]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_406] = [__v_22, __v_7, __v_17]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_22, __v_7, __v_17]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35425,8 +35505,8 @@ fn aiur_fn_406( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_19, __v_0, __v_22]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_19, __v_0, __v_22]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35436,8 +35516,8 @@ fn aiur_fn_406( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_19, __v_0, __v_22]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_19, __v_0, __v_22]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35447,8 +35527,8 @@ fn aiur_fn_406( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_15, __v_0, __v_18]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_15, __v_0, __v_18]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35458,8 +35538,8 @@ fn aiur_fn_406( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_13, __v_0, __v_16]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_13, __v_0, __v_16]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35469,8 +35549,8 @@ fn aiur_fn_406( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_9, __v_0, __v_12]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_9, __v_0, __v_12]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35480,46 +35560,46 @@ fn aiur_fn_406( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_5, __v_0, __v_8]; - record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_407] = [__v_5, __v_0, __v_8]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_407: usize = 3; -const IN_407: usize = 3; -const OUT_407: usize = 2; -fn aiur_fn_407( - inp: [G; IN_407], +const INPUT_SIZE_408: usize = 3; +const IN_408: usize = 3; +const OUT_408: usize = 2; +fn aiur_fn_408( + inp: [G; IN_408], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_407], 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_405] = { let __args: [G; IN_405] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __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_407] = [__v_6, __v_7]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_408] = [__v_6, __v_7]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __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_406] = { let __args: [G; IN_406] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -35528,27 +35608,27 @@ fn aiur_fn_407( 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_407] = [__v_13, __v_14]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_408] = [__v_13, __v_14]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_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_407] = [__v_14, __v_15]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_408] = [__v_14, __v_15]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_407] = [__v_14, __v_15]; - record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_408] = [__v_14, __v_15]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35559,48 +35639,48 @@ fn aiur_fn_407( }) } -const INPUT_SIZE_408: usize = 3; -const IN_408: usize = 3; -const OUT_408: usize = 1; -fn aiur_fn_408( - inp: [G; IN_408], +const INPUT_SIZE_409: usize = 3; +const IN_409: usize = 3; +const OUT_409: usize = 1; +fn aiur_fn_409( + inp: [G; IN_409], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_408], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __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_408] = [__v_4]; - record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_409] = [__v_4]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_4]; - record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_409] = [__v_4]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_409: usize = 3; -const IN_409: usize = 3; -const OUT_409: usize = 1; -fn aiur_fn_409( - inp: [G; IN_409], +const INPUT_SIZE_410: usize = 3; +const IN_410: usize = 3; +const OUT_410: usize = 1; +fn aiur_fn_410( + inp: [G; IN_410], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_409], 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]; @@ -35618,113 +35698,113 @@ fn aiur_fn_409( let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_9]; - record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_410] = [__v_9]; + record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_409] = [__v_7]; - record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_410] = [__v_7]; + record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_409] = [__v_7]; - record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_410] = [__v_7]; + record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_410: usize = 3; -const IN_410: usize = 3; -const OUT_410: usize = 1; -fn aiur_fn_410( - inp: [G; IN_410], +const INPUT_SIZE_411: usize = 3; +const IN_411: usize = 3; +const OUT_411: usize = 1; +fn aiur_fn_411( + inp: [G; IN_411], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_410], ExecError> { +) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(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_408] = { let __args: [G; IN_408] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __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_410] = [__v_4]; - record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_411] = [__v_4]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_410] = [__v_4]; - record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_411] = [__v_4]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_411: usize = 3; -const IN_411: usize = 3; -const OUT_411: usize = 1; -fn aiur_fn_411( - inp: [G; IN_411], +const INPUT_SIZE_412: usize = 3; +const IN_412: usize = 3; +const OUT_412: usize = 1; +fn aiur_fn_412( + inp: [G; IN_412], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_411], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __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_411] = [__v_6]; - record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_6]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_411] = [__v_7]; - record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_7]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __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_411] = [__v_8]; - record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_8]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_411] = [__v_8]; - record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_412] = [__v_8]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35735,15 +35815,15 @@ fn aiur_fn_411( }) } -const INPUT_SIZE_412: usize = 3; -const IN_412: usize = 3; -const OUT_412: usize = 1; -fn aiur_fn_412( - inp: [G; IN_412], +const INPUT_SIZE_413: usize = 3; +const IN_413: usize = 3; +const OUT_413: usize = 1; +fn aiur_fn_413( + inp: [G; IN_413], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_412], 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]; @@ -35762,16 +35842,16 @@ fn aiur_fn_412( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_11]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_11]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_11]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_11]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35784,30 +35864,30 @@ fn aiur_fn_412( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_14]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_14]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_12]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_12]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_11]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_11]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35820,145 +35900,145 @@ fn aiur_fn_412( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_14]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_14]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_12]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_12]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_11]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_11]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_7]; - record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_413] = [__v_7]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_413: usize = 3; -const IN_413: usize = 3; -const OUT_413: usize = 1; -fn aiur_fn_413( - inp: [G; IN_413], +const INPUT_SIZE_414: usize = 3; +const IN_414: usize = 3; +const OUT_414: usize = 1; +fn aiur_fn_414( + inp: [G; IN_414], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_413], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __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_413] = [__v_6]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_6]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_7]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_7]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __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_413] = [__v_8]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_8]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_9]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_9]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_10]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_10]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_413] = [__v_11]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_11]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_3, __v_4, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_3, __v_4, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_14]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_14]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __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_413] = [__v_15]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_15]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_15]; - record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_414] = [__v_15]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -35979,15 +36059,15 @@ fn aiur_fn_413( }) } -const INPUT_SIZE_414: usize = 3; -const IN_414: usize = 3; -const OUT_414: usize = 1; -fn aiur_fn_414( - inp: [G; IN_414], +const INPUT_SIZE_415: usize = 3; +const IN_415: usize = 3; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: [G; IN_415], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_414], 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]; @@ -36019,7 +36099,7 @@ fn aiur_fn_414( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); @@ -36050,42 +36130,42 @@ fn aiur_fn_414( match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_43]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_43]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_45]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_45]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_414] = [__v_48]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_48]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_49]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_49]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36096,47 +36176,47 @@ fn aiur_fn_414( }, _ => { let __v_38: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_38]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_38]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_25]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_25]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_22]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_22]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_9]; - record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_415] = [__v_9]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_415: usize = 7; -const IN_415: usize = 7; -const OUT_415: usize = 1; -fn aiur_fn_415( - inp: [G; IN_415], +const INPUT_SIZE_416: usize = 7; +const IN_416: usize = 7; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: [G; IN_416], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_415], ExecError> { +) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36149,32 +36229,32 @@ fn aiur_fn_415( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_8]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_416] = [__v_8]; + record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_415] = [__v_13]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_416] = [__v_13]; + record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!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_415] = { let __args: [G; IN_415] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_15]; - record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_416] = [__v_15]; + record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36183,15 +36263,15 @@ fn aiur_fn_415( }) } -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_417: usize = 2; +const IN_417: usize = 2; +const OUT_417: usize = 1; +fn aiur_fn_417( + inp: [G; IN_417], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_416], 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]; @@ -36222,21 +36302,21 @@ fn aiur_fn_416( let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_25]; - record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_417] = [__v_25]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_417: usize = 3; -const IN_417: usize = 3; -const OUT_417: usize = 1; -fn aiur_fn_417( - inp: [G; IN_417], +const INPUT_SIZE_418: usize = 3; +const IN_418: usize = 3; +const OUT_418: usize = 1; +fn aiur_fn_418( + inp: [G; IN_418], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_417], 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]; @@ -36256,15 +36336,15 @@ fn aiur_fn_417( match __v_7.as_canonical_u64() { 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_417] = [__v_11]; - record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_418] = [__v_11]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_11]; - record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_418] = [__v_11]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36277,16 +36357,16 @@ fn aiur_fn_417( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_11]; - record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_418] = [__v_11]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_417] = [__v_11]; - record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_418] = [__v_11]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36295,54 +36375,54 @@ fn aiur_fn_417( }) } -const INPUT_SIZE_418: usize = 3; -const IN_418: usize = 3; -const OUT_418: usize = 1; -fn aiur_fn_418( - inp: [G; IN_418], +const INPUT_SIZE_419: usize = 3; +const IN_419: usize = 3; +const OUT_419: usize = 1; +fn aiur_fn_419( + inp: [G; IN_419], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_418], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_6]; - record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_6]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_7]; - record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_419] = [__v_7]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_419: usize = 1; -const IN_419: usize = 1; -const OUT_419: usize = 1; -fn aiur_fn_419( - inp: [G; IN_419], +const INPUT_SIZE_420: usize = 1; +const IN_420: usize = 1; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: [G; IN_420], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_419], ExecError> { +) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -36399,114 +36479,114 @@ fn aiur_fn_419( match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); - let __ret: [G; OUT_419] = [__v_36]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_36]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_36]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_36]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_36]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_36]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_22]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_22]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_20]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_20]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_20]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_20]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_7]; - record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_420] = [__v_7]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!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_421: usize = 3; +const IN_421: usize = 3; +const OUT_421: usize = 1; +fn aiur_fn_421( + inp: [G; IN_421], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_420], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __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_420] = [__v_5]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_421] = [__v_5]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_6]; - record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_421] = [__v_6]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_421: usize = 4; -const IN_421: usize = 4; -const OUT_421: usize = 1; -fn aiur_fn_421( - inp: [G; IN_421], +const INPUT_SIZE_422: usize = 4; +const IN_422: usize = 4; +const OUT_422: usize = 1; +fn aiur_fn_422( + inp: [G; IN_422], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_421], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -36515,19 +36595,19 @@ fn aiur_fn_421( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_421] = [__v_11]; - record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_422] = [__v_11]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!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_328] = { let __args: [G; IN_328] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -36538,39 +36618,39 @@ fn aiur_fn_421( let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_23]; - record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_422] = [__v_23]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_421] = [__v_10]; - record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_422] = [__v_10]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_422: usize = 2; -const IN_422: usize = 2; -const OUT_422: usize = 1; -fn aiur_fn_422( - inp: [G; IN_422], +const INPUT_SIZE_423: usize = 2; +const IN_423: usize = 2; +const OUT_423: usize = 1; +fn aiur_fn_423( + inp: [G; IN_423], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_422], 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 __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -36586,58 +36666,58 @@ fn aiur_fn_422( match __v_8.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_422] = [__v_11]; - record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_423] = [__v_11]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_422] = [__v_11]; - record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_423] = [__v_11]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_422] = [__v_8]; - record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_423] = [__v_8]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_423: usize = 3; -const IN_423: usize = 3; -const OUT_423: usize = 1; -fn aiur_fn_423( - inp: [G; IN_423], +const INPUT_SIZE_424: usize = 3; +const IN_424: usize = 3; +const OUT_424: usize = 1; +fn aiur_fn_424( + inp: [G; IN_424], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_423], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_3]; - record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_424] = [__v_3]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_424: usize = 3; -const IN_424: usize = 3; -const OUT_424: usize = 1; -fn aiur_fn_424( - inp: [G; IN_424], +const INPUT_SIZE_425: usize = 3; +const IN_425: usize = 3; +const OUT_425: usize = 1; +fn aiur_fn_425( + inp: [G; IN_425], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_424], 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]; @@ -36660,22 +36740,22 @@ fn aiur_fn_424( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36688,16 +36768,16 @@ fn aiur_fn_424( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36714,26 +36794,26 @@ fn aiur_fn_424( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36746,31 +36826,31 @@ fn aiur_fn_424( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_13]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_13]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_424] = [__v_13]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_13]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36778,10 +36858,10 @@ fn aiur_fn_424( } }, _ => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36794,31 +36874,31 @@ fn aiur_fn_424( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_14]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_14]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36831,38 +36911,38 @@ fn aiur_fn_424( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_14]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_14]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_7]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_7]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { @@ -36873,28 +36953,28 @@ fn aiur_fn_424( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __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_424] = [__v_13]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_13]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_13]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_13]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36916,32 +36996,32 @@ fn aiur_fn_424( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_13]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_13]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_13]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_13]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_12]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_12]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_11]; - record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -36953,15 +37033,15 @@ fn aiur_fn_424( }) } -const INPUT_SIZE_425: usize = 4; -const IN_425: usize = 4; -const OUT_425: usize = 1; -fn aiur_fn_425( - inp: [G; IN_425], +const INPUT_SIZE_426: usize = 4; +const IN_426: usize = 4; +const OUT_426: usize = 1; +fn aiur_fn_426( + inp: [G; IN_426], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_425], 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]; @@ -36970,8 +37050,8 @@ fn aiur_fn_425( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_425] = [__v_4]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_4]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -36979,44 +37059,44 @@ fn aiur_fn_425( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_425] = [__v_5]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_5]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __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_425] = [__v_10]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_10]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_5, __v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_10]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_10]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_9]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_9]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37024,17 +37104,17 @@ fn aiur_fn_425( _ => { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_9]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_9]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_9]; - record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_426] = [__v_9]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37047,15 +37127,15 @@ fn aiur_fn_425( }) } -const INPUT_SIZE_426: usize = 12; -const IN_426: usize = 12; -const OUT_426: usize = 1; -fn aiur_fn_426( - inp: [G; IN_426], +const INPUT_SIZE_427: usize = 12; +const IN_427: usize = 12; +const OUT_427: usize = 1; +fn aiur_fn_427( + inp: [G; IN_427], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_426], 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]; @@ -37071,29 +37151,29 @@ fn aiur_fn_426( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_426] = [__v_5]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_5]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_426] = [__v_12]; - record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_427] = [__v_12]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_427: usize = 6; -const IN_427: usize = 6; -const OUT_427: usize = 1; -fn aiur_fn_427( - inp: [G; IN_427], +const INPUT_SIZE_428: usize = 6; +const IN_428: usize = 6; +const OUT_428: usize = 1; +fn aiur_fn_428( + inp: [G; IN_428], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_427], 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]; @@ -37131,24 +37211,24 @@ fn aiur_fn_427( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_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_427] = [__v_34]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_34]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_34]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_34]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37156,41 +37236,41 @@ fn aiur_fn_427( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_34]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_34]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_37]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_37]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!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 }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_38]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_38]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_38]; - record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_428] = [__v_38]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37203,147 +37283,147 @@ fn aiur_fn_427( }) } -const INPUT_SIZE_428: usize = 4; -const IN_428: usize = 4; -const OUT_428: usize = 1; -fn aiur_fn_428( - inp: [G; IN_428], +const INPUT_SIZE_429: usize = 4; +const IN_429: usize = 4; +const OUT_429: usize = 1; +fn aiur_fn_429( + inp: [G; IN_429], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_428], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_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_425] = { let __args: [G; IN_425] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_9]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_429] = [__v_9]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_428] = [__v_6]; - record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_429] = [__v_6]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_429: usize = 4; -const IN_429: usize = 4; -const OUT_429: usize = 1; -fn aiur_fn_429( - inp: [G; IN_429], +const INPUT_SIZE_430: usize = 4; +const IN_430: usize = 4; +const OUT_430: usize = 1; +fn aiur_fn_430( + inp: [G; IN_430], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_429], 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_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_425] = { let __args: [G; IN_425] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_9]; - record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_430] = [__v_9]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_429] = [__v_6]; - record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_430] = [__v_6]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_430: usize = 4; -const IN_430: usize = 4; -const OUT_430: usize = 1; -fn aiur_fn_430( - inp: [G; IN_430], +const INPUT_SIZE_431: usize = 4; +const IN_431: usize = 4; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: [G; IN_431], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_430], 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 __v_3: G = inp[3]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_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_425] = { let __args: [G; IN_425] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_12]; - record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_12]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_430] = [__v_8]; - record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_8]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_430] = [__v_6]; - record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_431] = [__v_6]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_431: usize = 5; -const IN_431: usize = 5; -const OUT_431: usize = 1; -fn aiur_fn_431( - inp: [G; IN_431], +const INPUT_SIZE_432: usize = 5; +const IN_432: usize = 5; +const OUT_432: usize = 1; +fn aiur_fn_432( + inp: [G; IN_432], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_431], 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]; @@ -37365,73 +37445,73 @@ fn aiur_fn_431( let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_19]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_19]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_383] = { let __args: [G; IN_383] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_431] = [__v_23]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_23]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __v_21, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_21, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_431] = [__v_25]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_25]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __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_400] = { let __args: [G; IN_400] = [__v_22, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_22, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); - let __ret: [G; OUT_431] = [__v_24]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_24]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = (__v_3 - __v_24); - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_22, __v_2, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_22, __v_2, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_431] = [__v_26]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_26]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_23]; - record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_432] = [__v_23]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37442,15 +37522,15 @@ fn aiur_fn_431( }) } -const INPUT_SIZE_432: usize = 5; -const IN_432: usize = 5; -const OUT_432: usize = 1; -fn aiur_fn_432( - inp: [G; IN_432], +const INPUT_SIZE_433: usize = 5; +const IN_433: usize = 5; +const OUT_433: usize = 1; +fn aiur_fn_433( + inp: [G; IN_433], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_432], 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]; @@ -37472,73 +37552,73 @@ fn aiur_fn_432( let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_432] = [__v_19]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_19]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __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_383] = { let __args: [G; IN_383] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_21, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_432] = [__v_23]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_23]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_21, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_21, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_25]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_25]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __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_400] = { let __args: [G; IN_400] = [__v_1, __v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); - let __ret: [G; OUT_432] = [__v_24]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_24]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = (__v_3 - __v_24); - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __v_22, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_22, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_26]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_26]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_432] = [__v_23]; - record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_433] = [__v_23]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37549,71 +37629,71 @@ fn aiur_fn_432( }) } -const INPUT_SIZE_433: usize = 4; -const IN_433: usize = 4; -const OUT_433: usize = 1; -fn aiur_fn_433( - inp: [G; IN_433], +const INPUT_SIZE_434: usize = 4; +const IN_434: usize = 4; +const OUT_434: usize = 1; +fn aiur_fn_434( + inp: [G; IN_434], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_433], 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 __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_433] = [__v_11]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_11]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 - __v_11); - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_9, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_9, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_13]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_13]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_433] = [__v_10]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_10]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!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_425] = { let __args: [G; IN_425] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_12]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_12]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37623,32 +37703,32 @@ fn aiur_fn_433( _ => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_433] = [__v_10]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_10]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!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_425] = { let __args: [G; IN_425] = [__v_0, __v_8, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_8, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_12]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_12]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_433] = [__v_8]; - record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_434] = [__v_8]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37657,15 +37737,15 @@ fn aiur_fn_433( }) } -const INPUT_SIZE_434: usize = 12; -const IN_434: usize = 12; -const OUT_434: usize = 1; -fn aiur_fn_434( - inp: [G; IN_434], +const INPUT_SIZE_435: usize = 12; +const IN_435: usize = 12; +const OUT_435: usize = 1; +fn aiur_fn_435( + inp: [G; IN_435], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_434], 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]; @@ -37682,35 +37762,35 @@ fn aiur_fn_434( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_434] = [__v_12]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_435] = [__v_12]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_434] = [__v_12]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_435] = [__v_12]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_12]; - record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_435] = [__v_12]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_435: usize = 1; -const IN_435: usize = 1; -const OUT_435: usize = 2; -fn aiur_fn_435( - inp: [G; IN_435], +const INPUT_SIZE_436: usize = 1; +const IN_436: usize = 1; +const OUT_436: usize = 2; +fn aiur_fn_436( + inp: [G; IN_436], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_435], ExecError> { +) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -37723,7 +37803,7 @@ fn aiur_fn_435( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -37733,37 +37813,37 @@ fn aiur_fn_435( let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_435] = [__v_11, __v_12]; - record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_436] = [__v_11, __v_12]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_435] = [__v_9, __v_0]; - record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_436] = [__v_9, __v_0]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_435] = [__v_7, __v_0]; - record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_436] = [__v_7, __v_0]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_436: usize = 1; -const IN_436: usize = 1; -const OUT_436: usize = 2; -fn aiur_fn_436( - inp: [G; IN_436], +const INPUT_SIZE_437: usize = 1; +const IN_437: usize = 1; +const OUT_437: usize = 2; +fn aiur_fn_437( + inp: [G; IN_437], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_436], ExecError> { +) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -37793,75 +37873,75 @@ fn aiur_fn_436( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_21, __v_22]; - record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_21, __v_22]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_21, __v_22]; - record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_21, __v_22]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_436] = [__v_20, __v_0]; - record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_20, __v_0]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_436] = [__v_7, __v_0]; - record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_437] = [__v_7, __v_0]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_437: usize = 3; -const IN_437: usize = 3; -const OUT_437: usize = 1; -fn aiur_fn_437( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_437], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __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_437] = [__v_7]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_7]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_7]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_7]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -37895,27 +37975,27 @@ fn aiur_fn_437( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __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_400] = { let __args: [G; IN_400] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_37]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_37]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_37]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_37]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37923,16 +38003,16 @@ fn aiur_fn_437( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_37]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_37]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_37]; - record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_438] = [__v_37]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -37948,15 +38028,15 @@ fn aiur_fn_437( }) } -const INPUT_SIZE_438: usize = 1; -const IN_438: usize = 1; -const OUT_438: usize = 2; -fn aiur_fn_438( - inp: [G; IN_438], +const INPUT_SIZE_439: usize = 1; +const IN_439: usize = 1; +const OUT_439: usize = 2; +fn aiur_fn_439( + inp: [G; IN_439], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_438], ExecError> { +) -> Result<[G; OUT_439], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; @@ -37970,8 +38050,8 @@ fn aiur_fn_438( match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_438] = [__v_4, __v_7]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_439] = [__v_4, __v_7]; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -38009,23 +38089,23 @@ fn aiur_fn_438( let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __ret: [G; OUT_438] = [__v_39, __v_40]; - record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_439] = [__v_39, __v_40]; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_439: usize = 14; -const IN_439: usize = 14; -const OUT_439: usize = 2; -fn aiur_fn_439( - inp: [G; IN_439], +const INPUT_SIZE_440: usize = 14; +const IN_440: usize = 14; +const OUT_440: usize = 2; +fn aiur_fn_440( + inp: [G; IN_440], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_439], 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]; @@ -38043,90 +38123,90 @@ fn aiur_fn_439( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_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_383] = { let __args: [G; IN_383] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_16, __v_17]; - record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_440] = [__v_16, __v_17]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_16, __v_0]; - record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_440] = [__v_16, __v_0]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_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_383] = { let __args: [G; IN_383] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_16, __v_17]; - record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_440] = [__v_16, __v_17]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_16, __v_0]; - record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_440] = [__v_16, __v_0]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_14, __v_0]; - record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_440] = [__v_14, __v_0]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_440: usize = 2; -const IN_440: usize = 2; -const OUT_440: usize = 1; -fn aiur_fn_440( - inp: [G; IN_440], +const INPUT_SIZE_441: usize = 2; +const IN_441: usize = 2; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: [G; IN_441], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_440], 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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_4]; - record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_441] = [__v_4]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_441: usize = 2; -const IN_441: usize = 2; -const OUT_441: usize = 1; -fn aiur_fn_441( - inp: [G; IN_441], +const INPUT_SIZE_442: usize = 2; +const IN_442: usize = 2; +const OUT_442: usize = 1; +fn aiur_fn_442( + inp: [G; IN_442], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_441], 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]; @@ -38137,10 +38217,10 @@ fn aiur_fn_441( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_6]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_6]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -38148,12 +38228,12 @@ fn aiur_fn_441( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_441] = [__v_12]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_12]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { @@ -38172,91 +38252,91 @@ fn aiur_fn_441( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __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_309] = { let __args: [G; IN_309] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_22]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_22]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_12]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_12]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_441] = [__v_12]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_12]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_441] = [__v_13]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_13]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_9]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_9]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_6]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_6]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_6]; - record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_442] = [__v_6]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -38266,15 +38346,15 @@ fn aiur_fn_441( }) } -const INPUT_SIZE_442: usize = 4; -const IN_442: usize = 4; -const OUT_442: usize = 1; -fn aiur_fn_442( - inp: [G; IN_442], +const INPUT_SIZE_443: usize = 4; +const IN_443: usize = 4; +const OUT_443: usize = 1; +fn aiur_fn_443( + inp: [G; IN_443], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_442], 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]; @@ -38286,20 +38366,20 @@ fn aiur_fn_442( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_442] = [__v_0]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_443] = [__v_0]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_9]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_443] = [__v_9]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -38312,7 +38392,7 @@ fn aiur_fn_442( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -38320,24 +38400,24 @@ fn aiur_fn_442( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_15]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_443] = [__v_15]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -38345,14 +38425,14 @@ fn aiur_fn_442( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -38361,16 +38441,16 @@ fn aiur_fn_442( let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_23]; - record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_443] = [__v_23]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -38387,30 +38467,30 @@ fn aiur_fn_442( }) } -const INPUT_SIZE_443: usize = 2; -const IN_443: usize = 2; -const OUT_443: usize = 1; -fn aiur_fn_443( - inp: [G; IN_443], +const INPUT_SIZE_444: usize = 2; +const IN_444: usize = 2; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: [G; IN_444], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_443], 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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_443] = [__v_8]; - record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_444] = [__v_8]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -38422,8 +38502,8 @@ fn aiur_fn_443( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_443] = [__v_8]; - record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_444] = [__v_8]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -38433,23 +38513,23 @@ fn aiur_fn_443( }) } -const INPUT_SIZE_444: usize = 4; -const IN_444: usize = 4; -const OUT_444: usize = 1; -fn aiur_fn_444( - inp: [G; IN_444], +const INPUT_SIZE_445: usize = 4; +const IN_445: usize = 4; +const OUT_445: usize = 1; +fn aiur_fn_445( + inp: [G; IN_445], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_444], 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]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -38461,10 +38541,10 @@ fn aiur_fn_444( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_13]; - record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_445] = [__v_13]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -38474,29 +38554,29 @@ fn aiur_fn_444( }) } -const INPUT_SIZE_445: usize = 3; -const IN_445: usize = 3; -const OUT_445: usize = 1; -fn aiur_fn_445( - inp: [G; IN_445], +const INPUT_SIZE_446: usize = 3; +const IN_446: usize = 3; +const OUT_446: usize = 1; +fn aiur_fn_446( + inp: [G; IN_446], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_445], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_3]; - record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_446] = [__v_3]; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -38509,15 +38589,15 @@ fn aiur_fn_445( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_12]; - record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_446] = [__v_12]; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_445] = [__v_3]; - record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_446] = [__v_3]; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -38526,54 +38606,54 @@ fn aiur_fn_445( }) } -const INPUT_SIZE_446: usize = 3; -const IN_446: usize = 3; -const OUT_446: usize = 0; -fn aiur_fn_446( - inp: [G; IN_446], +const INPUT_SIZE_447: usize = 3; +const IN_447: usize = 3; +const OUT_447: usize = 0; +fn aiur_fn_447( + inp: [G; IN_447], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_446], 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]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_446] = []; - record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_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_446] = []; - record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_447: usize = 4; -const IN_447: usize = 4; -const OUT_447: usize = 0; -fn aiur_fn_447( - inp: [G; IN_447], +const INPUT_SIZE_448: usize = 4; +const IN_448: usize = 4; +const OUT_448: usize = 0; +fn aiur_fn_448( + inp: [G; IN_448], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_447], 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]; @@ -38581,33 +38661,33 @@ fn aiur_fn_447( let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_447] = []; - record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_448] = []; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_447] = []; - record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_448] = []; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_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_447] = []; - record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_448] = []; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -38616,15 +38696,15 @@ fn aiur_fn_447( }) } -const INPUT_SIZE_448: usize = 7; -const IN_448: usize = 7; -const OUT_448: usize = 1; -fn aiur_fn_448( - inp: [G; IN_448], +const INPUT_SIZE_449: usize = 7; +const IN_449: usize = 7; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: [G; IN_449], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_448], 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]; @@ -38643,24 +38723,24 @@ fn aiur_fn_448( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_448] = [__v_8]; - record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_449] = [__v_8]; + record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_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_448] = { let __args: [G; IN_448] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_448] = [__v_18]; - record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_449] = [__v_18]; + record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -38672,23 +38752,23 @@ fn aiur_fn_448( }) } -const INPUT_SIZE_449: usize = 4; -const IN_449: usize = 4; -const OUT_449: usize = 1; -fn aiur_fn_449( - inp: [G; IN_449], +const INPUT_SIZE_450: usize = 4; +const IN_450: usize = 4; +const OUT_450: usize = 1; +fn aiur_fn_450( + inp: [G; IN_450], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_449], ExecError> { +) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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_440] = { let __args: [G; IN_440] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -38742,18 +38822,18 @@ fn aiur_fn_449( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_45]; - record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_450] = [__v_45]; + record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -38773,21 +38853,21 @@ fn aiur_fn_449( }) } -const INPUT_SIZE_450: usize = 2; -const IN_450: usize = 2; -const OUT_450: usize = 1; -fn aiur_fn_450( - inp: [G; IN_450], +const INPUT_SIZE_451: usize = 2; +const IN_451: usize = 2; +const OUT_451: usize = 1; +fn aiur_fn_451( + inp: [G; IN_451], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_450], ExecError> { +) -> Result<[G; OUT_451], 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_440] = { let __args: [G; IN_440] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -38796,8 +38876,8 @@ fn aiur_fn_450( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_450] = [__v_5]; - record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_451] = [__v_5]; + record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -38807,77 +38887,28 @@ fn aiur_fn_450( }) } -const INPUT_SIZE_451: usize = 3; -const IN_451: usize = 3; -const OUT_451: usize = 0; -fn aiur_fn_451( - inp: [G; IN_451], +const INPUT_SIZE_452: usize = 3; +const IN_452: usize = 3; +const OUT_452: usize = 0; +fn aiur_fn_452( + inp: [G; IN_452], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_451], 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_440] = { let __args: [G; IN_440] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __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_451] = []; - record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - -const INPUT_SIZE_452: usize = 0; -const IN_452: usize = 0; -const OUT_452: usize = 1; -fn aiur_fn_452( - inp: [G; IN_452], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_452], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(236); - let __v_1: G = G::from_u64(31); - let __v_2: G = G::from_u64(96); - let __v_3: G = G::from_u64(193); - let __v_4: G = G::from_u64(162); - let __v_5: G = G::from_u64(141); - let __v_6: G = G::from_u64(72); - let __v_7: G = G::from_u64(188); - let __v_8: G = G::from_u64(152); - let __v_9: G = G::from_u64(254); - let __v_10: G = G::from_u64(62); - let __v_11: G = G::from_u64(247); - let __v_12: G = G::from_u64(45); - let __v_13: G = G::from_u64(37); - let __v_14: G = G::from_u64(81); - let __v_15: G = G::from_u64(50); - let __v_16: G = G::from_u64(115); - let __v_17: G = G::from_u64(90); - let __v_18: G = G::from_u64(80); - let __v_19: G = G::from_u64(60); - let __v_20: G = G::from_u64(195); - let __v_21: G = G::from_u64(110); - let __v_22: G = G::from_u64(63); - let __v_23: G = G::from_u64(240); - let __v_24: G = G::from_u64(242); - let __v_25: G = G::from_u64(46); - let __v_26: G = G::from_u64(61); - let __v_27: G = G::from_u64(72); - let __v_28: G = G::from_u64(110); - let __v_29: G = G::from_u64(38); - let __v_30: G = G::from_u64(110); - let __v_31: G = G::from_u64(190); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_452] = [__v_32]; + let __ret: [G; OUT_452] = []; record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) @@ -38893,38 +38924,38 @@ fn aiur_fn_453( unconstrained: bool, ) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(180); - let __v_1: G = G::from_u64(178); - let __v_2: G = G::from_u64(108); - let __v_3: G = G::from_u64(46); - let __v_4: G = G::from_u64(41); - let __v_5: G = G::from_u64(147); - let __v_6: G = G::from_u64(28); - let __v_7: G = G::from_u64(6); - let __v_8: G = G::from_u64(232); - let __v_9: G = G::from_u64(133); - let __v_10: G = G::from_u64(145); - let __v_11: G = G::from_u64(70); - let __v_12: G = G::from_u64(19); - let __v_13: G = G::from_u64(250); - let __v_14: G = G::from_u64(255); - let __v_15: G = G::from_u64(88); - let __v_16: G = G::from_u64(86); - let __v_17: G = G::from_u64(19); - let __v_18: G = G::from_u64(142); - let __v_19: G = G::from_u64(92); - let __v_20: G = G::from_u64(176); - let __v_21: G = G::from_u64(150); - let __v_22: G = G::from_u64(32); - let __v_23: G = G::from_u64(221); - let __v_24: G = G::from_u64(182); - let __v_25: G = G::from_u64(146); - let __v_26: G = G::from_u64(26); - let __v_27: G = G::from_u64(52); - let __v_28: G = G::from_u64(45); - let __v_29: G = G::from_u64(237); - let __v_30: G = G::from_u64(137); - let __v_31: G = G::from_u64(87); + let __v_0: G = G::from_u64(8); + let __v_1: G = G::from_u64(250); + let __v_2: G = G::from_u64(173); + let __v_3: G = G::from_u64(94); + let __v_4: G = G::from_u64(146); + let __v_5: G = G::from_u64(49); + let __v_6: G = G::from_u64(110); + let __v_7: G = G::from_u64(23); + let __v_8: G = G::from_u64(229); + let __v_9: G = G::from_u64(248); + let __v_10: G = G::from_u64(8); + let __v_11: G = G::from_u64(4); + let __v_12: G = G::from_u64(152); + let __v_13: G = G::from_u64(44); + let __v_14: G = G::from_u64(111); + let __v_15: G = G::from_u64(133); + let __v_16: G = G::from_u64(62); + let __v_17: G = G::from_u64(50); + let __v_18: G = G::from_u64(188); + let __v_19: G = G::from_u64(67); + let __v_20: G = G::from_u64(244); + let __v_21: G = G::from_u64(220); + let __v_22: G = G::from_u64(65); + let __v_23: G = G::from_u64(6); + let __v_24: G = G::from_u64(25); + let __v_25: G = G::from_u64(236); + let __v_26: G = G::from_u64(19); + let __v_27: G = G::from_u64(223); + let __v_28: G = G::from_u64(21); + let __v_29: G = G::from_u64(35); + let __v_30: G = G::from_u64(119); + let __v_31: G = G::from_u64(227); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_453] = [__v_32]; record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38942,38 +38973,38 @@ fn aiur_fn_454( unconstrained: bool, ) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(192); - let __v_1: G = G::from_u64(19); - let __v_2: G = G::from_u64(193); - let __v_3: G = G::from_u64(83); - let __v_4: G = G::from_u64(235); - let __v_5: G = G::from_u64(240); - let __v_6: G = G::from_u64(32); - let __v_7: G = G::from_u64(40); - let __v_8: G = G::from_u64(174); - let __v_9: G = G::from_u64(210); - let __v_10: G = G::from_u64(100); - let __v_11: G = G::from_u64(51); - let __v_12: G = G::from_u64(60); - let __v_13: G = G::from_u64(30); - let __v_14: G = G::from_u64(76); - let __v_15: G = G::from_u64(133); - let __v_16: G = G::from_u64(1); - let __v_17: G = G::from_u64(125); - let __v_18: G = G::from_u64(11); - let __v_19: G = G::from_u64(135); - let __v_20: G = G::from_u64(2); - let __v_21: G = G::from_u64(93); - let __v_22: G = G::from_u64(117); - let __v_23: G = G::from_u64(150); - let __v_24: G = G::from_u64(169); - let __v_25: G = G::from_u64(105); - let __v_26: G = G::from_u64(113); - let __v_27: G = G::from_u64(187); - let __v_28: G = G::from_u64(43); - let __v_29: G = G::from_u64(103); - let __v_30: G = G::from_u64(146); - let __v_31: G = G::from_u64(29); + let __v_0: G = G::from_u64(103); + let __v_1: G = G::from_u64(110); + let __v_2: G = G::from_u64(135); + let __v_3: G = G::from_u64(221); + let __v_4: G = G::from_u64(229); + let __v_5: G = G::from_u64(207); + let __v_6: G = G::from_u64(48); + let __v_7: G = G::from_u64(192); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(105); + let __v_10: G = G::from_u64(11); + let __v_11: G = G::from_u64(187); + let __v_12: G = G::from_u64(231); + let __v_13: G = G::from_u64(171); + let __v_14: G = G::from_u64(116); + let __v_15: G = G::from_u64(252); + let __v_16: G = G::from_u64(169); + let __v_17: G = G::from_u64(43); + let __v_18: G = G::from_u64(10); + let __v_19: G = G::from_u64(166); + let __v_20: G = G::from_u64(18); + let __v_21: G = G::from_u64(237); + let __v_22: G = G::from_u64(158); + let __v_23: G = G::from_u64(243); + let __v_24: G = G::from_u64(202); + let __v_25: G = G::from_u64(248); + let __v_26: G = G::from_u64(159); + let __v_27: G = G::from_u64(29); + let __v_28: G = G::from_u64(158); + let __v_29: G = G::from_u64(106); + let __v_30: G = G::from_u64(36); + let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_454] = [__v_32]; record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38990,6 +39021,55 @@ fn aiur_fn_455( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_455], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(204); + let __v_1: G = G::from_u64(225); + let __v_2: G = G::from_u64(37); + let __v_3: G = G::from_u64(101); + let __v_4: G = G::from_u64(11); + let __v_5: G = G::from_u64(119); + let __v_6: G = G::from_u64(93); + let __v_7: G = G::from_u64(25); + let __v_8: G = G::from_u64(16); + let __v_9: G = G::from_u64(239); + let __v_10: G = G::from_u64(234); + let __v_11: G = G::from_u64(145); + let __v_12: G = G::from_u64(159); + let __v_13: G = G::from_u64(92); + let __v_14: G = G::from_u64(242); + let __v_15: G = G::from_u64(114); + let __v_16: G = G::from_u64(247); + let __v_17: G = G::from_u64(217); + let __v_18: G = G::from_u64(231); + let __v_19: G = G::from_u64(177); + let __v_20: G = G::from_u64(29); + let __v_21: G = G::from_u64(98); + let __v_22: G = G::from_u64(52); + let __v_23: G = G::from_u64(61); + let __v_24: G = G::from_u64(109); + let __v_25: G = G::from_u64(10); + let __v_26: G = G::from_u64(88); + let __v_27: G = G::from_u64(156); + let __v_28: G = G::from_u64(223); + let __v_29: G = G::from_u64(174); + let __v_30: G = G::from_u64(255); + let __v_31: G = G::from_u64(33); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_455] = [__v_32]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_456: usize = 0; +const IN_456: usize = 0; +const OUT_456: usize = 1; +fn aiur_fn_456( + inp: [G; IN_456], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(158); @@ -39024,21 +39104,21 @@ fn aiur_fn_455( let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(129); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_455] = [__v_32]; - record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_456] = [__v_32]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_456: usize = 0; -const IN_456: usize = 0; -const OUT_456: usize = 1; -fn aiur_fn_456( - inp: [G; IN_456], +const INPUT_SIZE_457: usize = 0; +const IN_457: usize = 0; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_456], ExecError> { +) -> Result<[G; OUT_457], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(113); @@ -39073,55 +39153,6 @@ fn aiur_fn_456( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(149); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_456] = [__v_32]; - record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - -const INPUT_SIZE_457: usize = 0; -const IN_457: usize = 0; -const OUT_457: usize = 1; -fn aiur_fn_457( - inp: [G; IN_457], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_457], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(33); - let __v_1: G = G::from_u64(224); - let __v_2: G = G::from_u64(224); - let __v_3: G = G::from_u64(120); - let __v_4: G = G::from_u64(59); - let __v_5: G = G::from_u64(118); - let __v_6: G = G::from_u64(23); - let __v_7: G = G::from_u64(176); - let __v_8: G = G::from_u64(204); - let __v_9: G = G::from_u64(78); - let __v_10: G = G::from_u64(255); - let __v_11: G = G::from_u64(77); - let __v_12: G = G::from_u64(31); - let __v_13: G = G::from_u64(171); - let __v_14: G = G::from_u64(124); - let __v_15: G = G::from_u64(255); - let __v_16: G = G::from_u64(239); - let __v_17: G = G::from_u64(224); - let __v_18: G = G::from_u64(28); - let __v_19: G = G::from_u64(212); - let __v_20: G = G::from_u64(61); - let __v_21: G = G::from_u64(167); - let __v_22: G = G::from_u64(126); - let __v_23: G = G::from_u64(47); - let __v_24: G = G::from_u64(152); - let __v_25: G = G::from_u64(209); - let __v_26: G = G::from_u64(80); - let __v_27: G = G::from_u64(148); - let __v_28: G = G::from_u64(160); - let __v_29: G = G::from_u64(216); - let __v_30: G = G::from_u64(240); - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_457] = [__v_32]; record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -39138,38 +39169,38 @@ fn aiur_fn_458( unconstrained: bool, ) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(1); - let __v_1: G = G::from_u64(131); - let __v_2: G = G::from_u64(89); - let __v_3: G = G::from_u64(91); - let __v_4: G = G::from_u64(131); - let __v_5: G = G::from_u64(123); - let __v_6: G = G::from_u64(155); - let __v_7: G = G::from_u64(132); - let __v_8: G = G::from_u64(218); - let __v_9: G = G::from_u64(95); - let __v_10: G = G::from_u64(0); - let __v_11: G = G::from_u64(75); - let __v_12: G = G::from_u64(138); - let __v_13: G = G::from_u64(196); - let __v_14: G = G::from_u64(164); - let __v_15: G = G::from_u64(187); - let __v_16: G = G::from_u64(211); - let __v_17: G = G::from_u64(188); - let __v_18: G = G::from_u64(6); - let __v_19: G = G::from_u64(40); - let __v_20: G = G::from_u64(185); - let __v_21: G = G::from_u64(156); - let __v_22: G = G::from_u64(141); - let __v_23: G = G::from_u64(85); - let __v_24: G = G::from_u64(14); - let __v_25: G = G::from_u64(179); - let __v_26: G = G::from_u64(81); - let __v_27: G = G::from_u64(247); - let __v_28: G = G::from_u64(76); - let __v_29: G = G::from_u64(225); - let __v_30: G = G::from_u64(109); - let __v_31: G = G::from_u64(72); + let __v_0: G = G::from_u64(203); + let __v_1: G = G::from_u64(31); + let __v_2: G = G::from_u64(165); + let __v_3: G = G::from_u64(173); + let __v_4: G = G::from_u64(62); + let __v_5: G = G::from_u64(99); + let __v_6: G = G::from_u64(44); + let __v_7: G = G::from_u64(7); + let __v_8: G = G::from_u64(180); + let __v_9: G = G::from_u64(136); + let __v_10: G = G::from_u64(40); + let __v_11: G = G::from_u64(175); + let __v_12: G = G::from_u64(96); + let __v_13: G = G::from_u64(79); + let __v_14: G = G::from_u64(115); + let __v_15: G = G::from_u64(199); + let __v_16: G = G::from_u64(10); + let __v_17: G = G::from_u64(130); + let __v_18: G = G::from_u64(11); + let __v_19: G = G::from_u64(29); + let __v_20: G = G::from_u64(228); + let __v_21: G = G::from_u64(161); + let __v_22: G = G::from_u64(59); + let __v_23: G = G::from_u64(171); + let __v_24: G = G::from_u64(243); + let __v_25: G = G::from_u64(31); + let __v_26: G = G::from_u64(43); + let __v_27: G = G::from_u64(120); + let __v_28: G = G::from_u64(150); + let __v_29: G = G::from_u64(247); + let __v_30: G = G::from_u64(249); + let __v_31: G = G::from_u64(186); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_458] = [__v_32]; record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39187,38 +39218,38 @@ fn aiur_fn_459( unconstrained: bool, ) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(156); - let __v_1: G = G::from_u64(230); - let __v_2: G = G::from_u64(227); - let __v_3: G = G::from_u64(34); - let __v_4: G = G::from_u64(241); - let __v_5: G = G::from_u64(148); - let __v_6: G = G::from_u64(129); - let __v_7: G = G::from_u64(242); - let __v_8: G = G::from_u64(28); - let __v_9: G = G::from_u64(244); - let __v_10: G = G::from_u64(196); - let __v_11: G = G::from_u64(143); - let __v_12: G = G::from_u64(136); - let __v_13: G = G::from_u64(120); - let __v_14: G = G::from_u64(152); - let __v_15: G = G::from_u64(118); - let __v_16: G = G::from_u64(182); - let __v_17: G = G::from_u64(155); - let __v_18: G = G::from_u64(138); - let __v_19: G = G::from_u64(155); - let __v_20: G = G::from_u64(21); - let __v_21: G = G::from_u64(32); - let __v_22: G = G::from_u64(67); - let __v_23: G = G::from_u64(156); - let __v_24: G = G::from_u64(16); - let __v_25: G = G::from_u64(29); - let __v_26: G = G::from_u64(152); - let __v_27: G = G::from_u64(63); - let __v_28: G = G::from_u64(150); - let __v_29: G = G::from_u64(234); - let __v_30: G = G::from_u64(96); - let __v_31: G = G::from_u64(183); + let __v_0: G = G::from_u64(234); + let __v_1: G = G::from_u64(117); + let __v_2: G = G::from_u64(97); + let __v_3: G = G::from_u64(219); + let __v_4: G = G::from_u64(37); + let __v_5: G = G::from_u64(170); + let __v_6: G = G::from_u64(36); + let __v_7: G = G::from_u64(206); + let __v_8: G = G::from_u64(72); + let __v_9: G = G::from_u64(28); + let __v_10: G = G::from_u64(227); + let __v_11: G = G::from_u64(233); + let __v_12: G = G::from_u64(238); + let __v_13: G = G::from_u64(141); + let __v_14: G = G::from_u64(112); + let __v_15: G = G::from_u64(77); + let __v_16: G = G::from_u64(72); + let __v_17: G = G::from_u64(61); + let __v_18: G = G::from_u64(217); + let __v_19: G = G::from_u64(5); + let __v_20: G = G::from_u64(103); + let __v_21: G = G::from_u64(87); + let __v_22: G = G::from_u64(218); + let __v_23: G = G::from_u64(126); + let __v_24: G = G::from_u64(218); + let __v_25: G = G::from_u64(36); + let __v_26: G = G::from_u64(181); + let __v_27: G = G::from_u64(17); + let __v_28: G = G::from_u64(27); + let __v_29: G = G::from_u64(229); + let __v_30: G = G::from_u64(155); + let __v_31: G = G::from_u64(194); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_459] = [__v_32]; record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39236,38 +39267,38 @@ fn aiur_fn_460( unconstrained: bool, ) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(60); - let __v_1: G = G::from_u64(245); - let __v_2: G = G::from_u64(77); - let __v_3: G = G::from_u64(51); - let __v_4: G = G::from_u64(56); - let __v_5: G = G::from_u64(33); - let __v_6: G = G::from_u64(221); - let __v_7: G = G::from_u64(55); - let __v_8: G = G::from_u64(104); - let __v_9: G = G::from_u64(58); - let __v_10: G = G::from_u64(11); - let __v_11: G = G::from_u64(243); - let __v_12: G = G::from_u64(135); - let __v_13: G = G::from_u64(57); - let __v_14: G = G::from_u64(230); - let __v_15: G = G::from_u64(135); - let __v_16: G = G::from_u64(97); - let __v_17: G = G::from_u64(10); - let __v_18: G = G::from_u64(25); - let __v_19: G = G::from_u64(145); - let __v_20: G = G::from_u64(117); - let __v_21: G = G::from_u64(146); - let __v_22: G = G::from_u64(32); - let __v_23: G = G::from_u64(183); - let __v_24: G = G::from_u64(126); - let __v_25: G = G::from_u64(222); - let __v_26: G = G::from_u64(195); - let __v_27: G = G::from_u64(56); - let __v_28: G = G::from_u64(186); - let __v_29: G = G::from_u64(60); - let __v_30: G = G::from_u64(251); - let __v_31: G = G::from_u64(200); + let __v_0: G = G::from_u64(203); + let __v_1: G = G::from_u64(15); + let __v_2: G = G::from_u64(240); + let __v_3: G = G::from_u64(125); + let __v_4: G = G::from_u64(63); + let __v_5: G = G::from_u64(114); + let __v_6: G = G::from_u64(38); + let __v_7: G = G::from_u64(168); + let __v_8: G = G::from_u64(152); + let __v_9: G = G::from_u64(118); + let __v_10: G = G::from_u64(157); + let __v_11: G = G::from_u64(168); + let __v_12: G = G::from_u64(202); + let __v_13: G = G::from_u64(172); + let __v_14: G = G::from_u64(154); + let __v_15: G = G::from_u64(193); + let __v_16: G = G::from_u64(180); + let __v_17: G = G::from_u64(146); + let __v_18: G = G::from_u64(38); + let __v_19: G = G::from_u64(214); + let __v_20: G = G::from_u64(174); + let __v_21: G = G::from_u64(67); + let __v_22: G = G::from_u64(178); + let __v_23: G = G::from_u64(175); + let __v_24: G = G::from_u64(252); + let __v_25: G = G::from_u64(132); + let __v_26: G = G::from_u64(154); + let __v_27: G = G::from_u64(151); + let __v_28: G = G::from_u64(249); + let __v_29: G = G::from_u64(211); + let __v_30: G = G::from_u64(229); + let __v_31: G = G::from_u64(199); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_460] = [__v_32]; record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39284,6 +39315,55 @@ fn aiur_fn_461( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_461], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(121); + let __v_1: G = G::from_u64(165); + let __v_2: G = G::from_u64(126); + let __v_3: G = G::from_u64(127); + let __v_4: G = G::from_u64(141); + let __v_5: G = G::from_u64(16); + let __v_6: G = G::from_u64(48); + let __v_7: G = G::from_u64(251); + let __v_8: G = G::from_u64(149); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(79); + let __v_11: G = G::from_u64(25); + let __v_12: G = G::from_u64(234); + let __v_13: G = G::from_u64(33); + let __v_14: G = G::from_u64(44); + let __v_15: G = G::from_u64(154); + let __v_16: G = G::from_u64(224); + let __v_17: G = G::from_u64(17); + let __v_18: G = G::from_u64(99); + let __v_19: G = G::from_u64(143); + let __v_20: G = G::from_u64(247); + let __v_21: G = G::from_u64(52); + let __v_22: G = G::from_u64(156); + let __v_23: G = G::from_u64(74); + let __v_24: G = G::from_u64(105); + let __v_25: G = G::from_u64(45); + let __v_26: G = G::from_u64(223); + let __v_27: G = G::from_u64(94); + let __v_28: G = G::from_u64(142); + let __v_29: G = G::from_u64(7); + let __v_30: G = G::from_u64(26); + let __v_31: G = G::from_u64(212); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_461] = [__v_32]; + record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_462: usize = 0; +const IN_462: usize = 0; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(230); let __v_1: G = G::from_u64(235); @@ -39318,21 +39398,21 @@ fn aiur_fn_461( let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_461] = [__v_32]; - record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_462] = [__v_32]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_462: usize = 0; -const IN_462: usize = 0; -const OUT_462: usize = 1; -fn aiur_fn_462( - inp: [G; IN_462], +const INPUT_SIZE_463: usize = 0; +const IN_463: usize = 0; +const OUT_463: usize = 1; +fn aiur_fn_463( + inp: [G; IN_463], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_462], ExecError> { +) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(108); let __v_1: G = G::from_u64(155); @@ -39367,55 +39447,6 @@ fn aiur_fn_462( let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(206); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_462] = [__v_32]; - record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - -const INPUT_SIZE_463: usize = 0; -const IN_463: usize = 0; -const OUT_463: usize = 1; -fn aiur_fn_463( - inp: [G; IN_463], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_463], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(131); - let __v_1: G = G::from_u64(253); - let __v_2: G = G::from_u64(227); - let __v_3: G = G::from_u64(143); - let __v_4: G = G::from_u64(170); - let __v_5: G = G::from_u64(17); - let __v_6: G = G::from_u64(100); - let __v_7: G = G::from_u64(100); - let __v_8: G = G::from_u64(142); - let __v_9: G = G::from_u64(66); - let __v_10: G = G::from_u64(39); - let __v_11: G = G::from_u64(151); - let __v_12: G = G::from_u64(90); - let __v_13: G = G::from_u64(191); - let __v_14: G = G::from_u64(46); - let __v_15: G = G::from_u64(140); - let __v_16: G = G::from_u64(38); - let __v_17: G = G::from_u64(13); - let __v_18: G = G::from_u64(125); - let __v_19: G = G::from_u64(78); - let __v_20: G = G::from_u64(241); - let __v_21: G = G::from_u64(201); - let __v_22: G = G::from_u64(38); - let __v_23: G = G::from_u64(118); - let __v_24: G = G::from_u64(33); - let __v_25: G = G::from_u64(79); - let __v_26: G = G::from_u64(254); - let __v_27: G = G::from_u64(88); - let __v_28: G = G::from_u64(38); - let __v_29: G = G::from_u64(194); - let __v_30: G = G::from_u64(7); - 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_463] = [__v_32]; record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -39432,38 +39463,38 @@ fn aiur_fn_464( unconstrained: bool, ) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(56); - let __v_1: G = G::from_u64(214); - let __v_2: G = G::from_u64(15); - let __v_3: G = G::from_u64(250); - let __v_4: G = G::from_u64(7); - let __v_5: G = G::from_u64(181); - let __v_6: G = G::from_u64(6); - let __v_7: G = G::from_u64(120); - let __v_8: G = G::from_u64(208); - let __v_9: G = G::from_u64(195); - let __v_10: G = G::from_u64(191); - let __v_11: G = G::from_u64(12); - let __v_12: G = G::from_u64(6); - let __v_13: G = G::from_u64(248); - let __v_14: G = G::from_u64(108); - let __v_15: G = G::from_u64(215); - let __v_16: G = G::from_u64(150); - let __v_17: G = G::from_u64(123); - let __v_18: G = G::from_u64(53); - let __v_19: G = G::from_u64(232); - let __v_20: G = G::from_u64(122); - let __v_21: G = G::from_u64(176); - let __v_22: G = G::from_u64(113); - let __v_23: G = G::from_u64(188); - let __v_24: G = G::from_u64(85); - let __v_25: G = G::from_u64(137); - let __v_26: G = G::from_u64(159); - let __v_27: G = G::from_u64(203); - let __v_28: G = G::from_u64(174); - let __v_29: G = G::from_u64(212); - let __v_30: G = G::from_u64(116); - let __v_31: G = G::from_u64(79); + let __v_0: G = G::from_u64(64); + let __v_1: G = G::from_u64(44); + let __v_2: G = G::from_u64(176); + let __v_3: G = G::from_u64(27); + let __v_4: G = G::from_u64(250); + let __v_5: G = G::from_u64(82); + let __v_6: G = G::from_u64(254); + let __v_7: G = G::from_u64(147); + let __v_8: G = G::from_u64(174); + let __v_9: G = G::from_u64(243); + let __v_10: G = G::from_u64(217); + let __v_11: G = G::from_u64(110); + let __v_12: G = G::from_u64(125); + let __v_13: G = G::from_u64(40); + let __v_14: G = G::from_u64(238); + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(224); + let __v_17: G = G::from_u64(225); + let __v_18: G = G::from_u64(247); + let __v_19: G = G::from_u64(111); + let __v_20: G = G::from_u64(60); + let __v_21: G = G::from_u64(135); + let __v_22: G = G::from_u64(150); + let __v_23: G = G::from_u64(84); + let __v_24: G = G::from_u64(245); + let __v_25: G = G::from_u64(231); + let __v_26: G = G::from_u64(25); + let __v_27: G = G::from_u64(167); + let __v_28: G = G::from_u64(32); + let __v_29: G = G::from_u64(21); + let __v_30: G = G::from_u64(35); + let __v_31: G = G::from_u64(127); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_464] = [__v_32]; record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39481,38 +39512,38 @@ fn aiur_fn_465( unconstrained: bool, ) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(85); - let __v_1: G = G::from_u64(104); - let __v_2: G = G::from_u64(231); - let __v_3: G = G::from_u64(153); - let __v_4: G = G::from_u64(25); - let __v_5: G = G::from_u64(141); - let __v_6: G = G::from_u64(173); - let __v_7: G = G::from_u64(159); - let __v_8: G = G::from_u64(171); - let __v_9: G = G::from_u64(14); - let __v_10: G = G::from_u64(120); - let __v_11: G = G::from_u64(75); - let __v_12: G = G::from_u64(122); - let __v_13: G = G::from_u64(76); - let __v_14: G = G::from_u64(88); - let __v_15: G = G::from_u64(17); - let __v_16: G = G::from_u64(43); - let __v_17: G = G::from_u64(252); - let __v_18: G = G::from_u64(38); - let __v_19: G = G::from_u64(136); - let __v_20: G = G::from_u64(174); - let __v_21: G = G::from_u64(206); - let __v_22: G = G::from_u64(190); - let __v_23: G = G::from_u64(60); - let __v_24: G = G::from_u64(44); - let __v_25: G = G::from_u64(101); - let __v_26: G = G::from_u64(99); - let __v_27: G = G::from_u64(48); - let __v_28: G = G::from_u64(66); - let __v_29: G = G::from_u64(16); - let __v_30: G = G::from_u64(249); - let __v_31: G = G::from_u64(86); + let __v_0: G = G::from_u64(191); + let __v_1: G = G::from_u64(254); + let __v_2: G = G::from_u64(215); + let __v_3: G = G::from_u64(205); + let __v_4: G = G::from_u64(73); + let __v_5: G = G::from_u64(104); + let __v_6: G = G::from_u64(184); + let __v_7: G = G::from_u64(252); + let __v_8: G = G::from_u64(37); + let __v_9: G = G::from_u64(30); + let __v_10: G = G::from_u64(210); + let __v_11: G = G::from_u64(74); + let __v_12: G = G::from_u64(156); + let __v_13: G = G::from_u64(37); + let __v_14: G = G::from_u64(61); + let __v_15: G = G::from_u64(160); + let __v_16: G = G::from_u64(2); + let __v_17: G = G::from_u64(21); + let __v_18: G = G::from_u64(144); + let __v_19: G = G::from_u64(35); + let __v_20: G = G::from_u64(84); + let __v_21: G = G::from_u64(194); + let __v_22: G = G::from_u64(148); + let __v_23: G = G::from_u64(79); + let __v_24: G = G::from_u64(89); + let __v_25: G = G::from_u64(232); + let __v_26: G = G::from_u64(21); + let __v_27: G = G::from_u64(56); + let __v_28: G = G::from_u64(220); + let __v_29: G = G::from_u64(26); + let __v_30: G = G::from_u64(226); + let __v_31: G = G::from_u64(199); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_465] = [__v_32]; record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39529,6 +39560,55 @@ fn aiur_fn_466( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_466], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(9); + let __v_1: G = G::from_u64(181); + let __v_2: G = G::from_u64(251); + let __v_3: G = G::from_u64(47); + let __v_4: G = G::from_u64(45); + let __v_5: G = G::from_u64(132); + let __v_6: G = G::from_u64(81); + let __v_7: G = G::from_u64(104); + let __v_8: G = G::from_u64(159); + let __v_9: G = G::from_u64(132); + let __v_10: G = G::from_u64(39); + let __v_11: G = G::from_u64(17); + let __v_12: G = G::from_u64(116); + let __v_13: G = G::from_u64(74); + let __v_14: G = G::from_u64(39); + let __v_15: G = G::from_u64(191); + let __v_16: G = G::from_u64(229); + let __v_17: G = G::from_u64(92); + let __v_18: G = G::from_u64(111); + let __v_19: G = G::from_u64(213); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(15); + let __v_22: G = G::from_u64(210); + let __v_23: G = G::from_u64(74); + let __v_24: G = G::from_u64(144); + let __v_25: G = G::from_u64(132); + let __v_26: G = G::from_u64(83); + let __v_27: G = G::from_u64(147); + let __v_28: G = G::from_u64(199); + let __v_29: G = G::from_u64(7); + let __v_30: G = G::from_u64(224); + let __v_31: G = G::from_u64(164); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_466] = [__v_32]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_467: usize = 0; +const IN_467: usize = 0; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: [G; IN_467], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(188); @@ -39563,21 +39643,21 @@ fn aiur_fn_466( let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(220); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_466] = [__v_32]; - record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_467] = [__v_32]; + record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_467: usize = 0; -const IN_467: usize = 0; -const OUT_467: usize = 1; -fn aiur_fn_467( - inp: [G; IN_467], +const INPUT_SIZE_468: usize = 0; +const IN_468: usize = 0; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: [G; IN_468], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_467], ExecError> { +) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(38); let __v_1: G = G::from_u64(124); @@ -39612,98 +39692,98 @@ fn aiur_fn_467( let __v_30: G = G::from_u64(73); let __v_31: G = G::from_u64(241); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_467] = [__v_32]; - record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_468] = [__v_32]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_468: usize = 1; -const IN_468: usize = 1; -const OUT_468: usize = 1; -fn aiur_fn_468( - inp: [G; IN_468], +const INPUT_SIZE_469: usize = 1; +const IN_469: usize = 1; +const OUT_469: usize = 1; +fn aiur_fn_469( + inp: [G; IN_469], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_468], ExecError> { +) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_3]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_3]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_5]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_5]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_7]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_7]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_9]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_9]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_11]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_11]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_13]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_13]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_13]; - record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_469] = [__v_13]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -39720,56 +39800,56 @@ fn aiur_fn_468( }) } -const INPUT_SIZE_469: usize = 1; -const IN_469: usize = 1; -const OUT_469: usize = 1; -fn aiur_fn_469( - inp: [G; IN_469], +const INPUT_SIZE_470: usize = 1; +const IN_470: usize = 1; +const OUT_470: usize = 1; +fn aiur_fn_470( + inp: [G; IN_470], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_469], ExecError> { +) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_3]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_470] = [__v_3]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_5]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_470] = [__v_5]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_7]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_470] = [__v_7]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_469] = [__v_7]; - record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_470] = [__v_7]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -39780,15 +39860,15 @@ fn aiur_fn_469( }) } -const INPUT_SIZE_470: usize = 1; -const IN_470: usize = 1; -const OUT_470: usize = 3; -fn aiur_fn_470( - inp: [G; IN_470], +const INPUT_SIZE_471: usize = 1; +const IN_471: usize = 1; +const OUT_471: usize = 3; +fn aiur_fn_471( + inp: [G; IN_471], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_470], ExecError> { +) -> Result<[G; OUT_471], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39805,11 +39885,11 @@ fn aiur_fn_470( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -39821,8 +39901,8 @@ fn aiur_fn_470( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_470] = [__v_14, __v_15, __v_18]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_471] = [__v_14, __v_15, __v_18]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -39836,8 +39916,8 @@ fn aiur_fn_470( match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); - let __ret: [G; OUT_470] = [__v_18, __v_12, __v_16]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_471] = [__v_18, __v_12, __v_16]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -39846,8 +39926,8 @@ fn aiur_fn_470( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_470] = [__v_18, __v_19, __v_22]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_471] = [__v_18, __v_19, __v_22]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -39858,8 +39938,8 @@ fn aiur_fn_470( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_470] = [__v_18, __v_19, __v_22]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_471] = [__v_18, __v_19, __v_22]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -39872,8 +39952,8 @@ fn aiur_fn_470( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_470] = [__v_9, __v_10, __v_13]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_471] = [__v_9, __v_10, __v_13]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -39884,34 +39964,34 @@ fn aiur_fn_470( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_470] = [__v_5, __v_6, __v_9]; - record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_471] = [__v_5, __v_6, __v_9]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_471: usize = 2; -const IN_471: usize = 2; -const OUT_471: usize = 1; -fn aiur_fn_471( - inp: [G; IN_471], +const INPUT_SIZE_472: usize = 2; +const IN_472: usize = 2; +const OUT_472: usize = 1; +fn aiur_fn_472( + inp: [G; IN_472], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_471], ExecError> { +) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -39931,27 +40011,27 @@ fn aiur_fn_471( let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_471] = [__v_15]; - record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_472] = [__v_15]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_472: usize = 4; -const IN_472: usize = 4; -const OUT_472: usize = 2; -fn aiur_fn_472( - inp: [G; IN_472], +const INPUT_SIZE_473: usize = 4; +const IN_473: usize = 4; +const OUT_473: usize = 2; +fn aiur_fn_473( + inp: [G; IN_473], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_472], 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 __v_3: G = inp[3]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -39962,24 +40042,24 @@ fn aiur_fn_472( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_472] = [__v_7, __v_11]; - record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_473] = [__v_7, __v_11]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __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_470] = { let __args: [G; IN_470] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -39990,26 +40070,26 @@ fn aiur_fn_472( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_472] = [__v_17, __v_21]; - record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_473] = [__v_17, __v_21]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_472] = [__v_17, __v_18]; - record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_473] = [__v_17, __v_18]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_472] = [__v_14, __v_15]; - record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_473] = [__v_14, __v_15]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40018,15 +40098,15 @@ fn aiur_fn_472( }) } -const INPUT_SIZE_473: usize = 6; -const IN_473: usize = 6; -const OUT_473: usize = 2; -fn aiur_fn_473( - inp: [G; IN_473], +const INPUT_SIZE_474: usize = 6; +const IN_474: usize = 6; +const OUT_474: usize = 2; +fn aiur_fn_474( + inp: [G; IN_474], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_473], 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]; @@ -40034,25 +40114,25 @@ fn aiur_fn_473( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __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_470] = { let __args: [G; IN_470] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __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_471] = { let __args: [G; IN_471] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); @@ -40064,13 +40144,13 @@ fn aiur_fn_473( let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_473] = [__v_27, __v_28]; - record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_474] = [__v_27, __v_28]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -40079,8 +40159,8 @@ fn aiur_fn_473( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_473] = [__v_14, __v_18]; - record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_474] = [__v_14, __v_18]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40091,29 +40171,29 @@ fn aiur_fn_473( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_473] = [__v_11, __v_15]; - record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_474] = [__v_11, __v_15]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_474: usize = 4; -const IN_474: usize = 4; -const OUT_474: usize = 2; -fn aiur_fn_474( - inp: [G; IN_474], +const INPUT_SIZE_475: usize = 4; +const IN_475: usize = 4; +const OUT_475: usize = 2; +fn aiur_fn_475( + inp: [G; IN_475], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_474], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40124,50 +40204,50 @@ fn aiur_fn_474( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_474] = [__v_7, __v_11]; - record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_475] = [__v_7, __v_11]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_474] = [__v_8, __v_9]; - record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_475] = [__v_8, __v_9]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_474] = [__v_14, __v_15]; - record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_475] = [__v_14, __v_15]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_474] = [__v_14, __v_15]; - record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_475] = [__v_14, __v_15]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40178,26 +40258,26 @@ fn aiur_fn_474( }) } -const INPUT_SIZE_475: usize = 3; -const IN_475: usize = 3; -const OUT_475: usize = 2; -fn aiur_fn_475( - inp: [G; IN_475], +const INPUT_SIZE_476: usize = 3; +const IN_476: usize = 3; +const OUT_476: usize = 2; +fn aiur_fn_476( + inp: [G; IN_476], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_475], 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 __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -40209,8 +40289,8 @@ fn aiur_fn_475( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_475] = [__v_10, __v_14]; - record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_476] = [__v_10, __v_14]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -40219,7 +40299,7 @@ fn aiur_fn_475( let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -40230,13 +40310,13 @@ fn aiur_fn_475( let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_475] = [__v_24, __v_25]; - record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_476] = [__v_24, __v_25]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -40246,15 +40326,15 @@ fn aiur_fn_475( }) } -const INPUT_SIZE_476: usize = 6; -const IN_476: usize = 6; -const OUT_476: usize = 2; -fn aiur_fn_476( - inp: [G; IN_476], +const INPUT_SIZE_477: usize = 6; +const IN_477: usize = 6; +const OUT_477: usize = 2; +fn aiur_fn_477( + inp: [G; IN_477], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_476], 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]; @@ -40263,14 +40343,14 @@ fn aiur_fn_476( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -40282,8 +40362,8 @@ fn aiur_fn_476( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_476] = [__v_14, __v_18]; - record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_477] = [__v_14, __v_18]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -40297,8 +40377,8 @@ fn aiur_fn_476( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_476] = [__v_16, __v_20]; - record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_477] = [__v_16, __v_20]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -40309,18 +40389,18 @@ fn aiur_fn_476( break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_476] = [__v_17, __v_18]; - record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_477] = [__v_17, __v_18]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -40335,15 +40415,15 @@ fn aiur_fn_476( }) } -const INPUT_SIZE_477: usize = 9; -const IN_477: usize = 9; -const OUT_477: usize = 2; -fn aiur_fn_477( - inp: [G; IN_477], +const INPUT_SIZE_478: usize = 9; +const IN_478: usize = 9; +const OUT_478: usize = 2; +fn aiur_fn_478( + inp: [G; IN_478], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_477], 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]; @@ -40364,8 +40444,8 @@ fn aiur_fn_477( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_477] = [__v_12, __v_16]; - record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_478] = [__v_12, __v_16]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -40381,12 +40461,12 @@ fn aiur_fn_477( let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); @@ -40423,12 +40503,12 @@ fn aiur_fn_477( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -40437,12 +40517,12 @@ fn aiur_fn_477( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -40466,31 +40546,31 @@ fn aiur_fn_477( let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; - let __ret: [G; OUT_477] = [__v_63, __v_64]; - record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_478] = [__v_63, __v_64]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_478: usize = 3; -const IN_478: usize = 3; -const OUT_478: usize = 2; -fn aiur_fn_478( - inp: [G; IN_478], +const INPUT_SIZE_479: usize = 3; +const IN_479: usize = 3; +const OUT_479: usize = 2; +fn aiur_fn_479( + inp: [G; IN_479], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_478], 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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40501,16 +40581,16 @@ fn aiur_fn_478( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_6, __v_10]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_6, __v_10]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -40530,7 +40610,7 @@ fn aiur_fn_478( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -40539,16 +40619,16 @@ fn aiur_fn_478( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_19, __v_23]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_19, __v_23]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_478] = [__v_19, __v_20]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_19, __v_20]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40559,8 +40639,8 @@ fn aiur_fn_478( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_18, __v_22]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_18, __v_22]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40571,8 +40651,8 @@ fn aiur_fn_478( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_18, __v_22]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_18, __v_22]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40583,8 +40663,8 @@ fn aiur_fn_478( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_14, __v_18]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_14, __v_18]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40595,8 +40675,8 @@ fn aiur_fn_478( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_14, __v_18]; - record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_479] = [__v_14, __v_18]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -40605,15 +40685,15 @@ fn aiur_fn_478( }) } -const INPUT_SIZE_479: usize = 4; -const IN_479: usize = 4; -const OUT_479: usize = 2; -fn aiur_fn_479( - inp: [G; IN_479], +const INPUT_SIZE_480: usize = 4; +const IN_480: usize = 4; +const OUT_480: usize = 2; +fn aiur_fn_480( + inp: [G; IN_480], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_479], 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]; @@ -40631,7 +40711,7 @@ fn aiur_fn_479( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -40660,18 +40740,18 @@ fn aiur_fn_479( let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40682,16 +40762,16 @@ fn aiur_fn_479( let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_52, __v_56]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_480] = [__v_52, __v_56]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); @@ -40705,28 +40785,28 @@ fn aiur_fn_479( let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_479] = [__v_69, __v_70]; - record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_480] = [__v_69, __v_70]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_480: usize = 6; -const IN_480: usize = 6; -const OUT_480: usize = 2; -fn aiur_fn_480( - inp: [G; IN_480], +const INPUT_SIZE_481: usize = 6; +const IN_481: usize = 6; +const OUT_481: usize = 2; +fn aiur_fn_481( + inp: [G; IN_481], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_480], 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]; @@ -40736,12 +40816,12 @@ fn aiur_fn_480( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -40752,18 +40832,18 @@ fn aiur_fn_480( let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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 }; @@ -40774,13 +40854,13 @@ fn aiur_fn_480( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_480] = [__v_20, __v_24]; - record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_481] = [__v_20, __v_24]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); @@ -40795,28 +40875,28 @@ fn aiur_fn_480( let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_480] = [__v_36, __v_37]; - record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_481] = [__v_36, __v_37]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_481: usize = 2; -const IN_481: usize = 2; -const OUT_481: usize = 1; -fn aiur_fn_481( - inp: [G; IN_481], +const INPUT_SIZE_482: usize = 2; +const IN_482: usize = 2; +const OUT_482: usize = 1; +fn aiur_fn_482( + inp: [G; IN_482], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_481], 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]; @@ -40824,8 +40904,8 @@ fn aiur_fn_481( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_481] = [__v_3]; - record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_482] = [__v_3]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -40833,14 +40913,14 @@ fn aiur_fn_481( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_481] = [__v_4]; - record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_482] = [__v_4]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_481] = [__v_4]; - record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_482] = [__v_4]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -40852,51 +40932,33 @@ fn aiur_fn_481( }) } -const INPUT_SIZE_482: usize = 2; -const IN_482: usize = 2; -const OUT_482: usize = 1; -fn aiur_fn_482( - inp: [G; IN_482], +const INPUT_SIZE_483: usize = 2; +const IN_483: usize = 2; +const OUT_483: usize = 1; +fn aiur_fn_483( + inp: [G; IN_483], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_482], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_482] = [__v_1]; - record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_483] = [__v_1]; + record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_482] = [__v_0]; - record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_483] = [__v_0]; + record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_483: usize = 0; -const IN_483: usize = 0; -const OUT_483: usize = 2; -fn aiur_fn_483( - inp: [G; IN_483], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_483], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(0); - let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_483] = [__v_0, __v_1]; - record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }) -} - const INPUT_SIZE_484: usize = 0; const IN_484: usize = 0; const OUT_484: usize = 2; @@ -40907,7 +40969,7 @@ fn aiur_fn_484( unconstrained: bool, ) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(1); + let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_484] = [__v_0, __v_1]; record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40925,7 +40987,7 @@ fn aiur_fn_485( unconstrained: bool, ) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(2); + let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_0, __v_1]; record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40933,8 +40995,8 @@ fn aiur_fn_485( }) } -const INPUT_SIZE_486: usize = 4; -const IN_486: usize = 4; +const INPUT_SIZE_486: usize = 0; +const IN_486: usize = 0; const OUT_486: usize = 2; fn aiur_fn_486( inp: [G; IN_486], @@ -40942,6 +41004,24 @@ fn aiur_fn_486( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_486], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(2); + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_486] = [__v_0, __v_1]; + record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_487: usize = 4; +const IN_487: usize = 4; +const OUT_487: usize = 2; +fn aiur_fn_487( + inp: [G; IN_487], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; @@ -40950,46 +41030,46 @@ fn aiur_fn_486( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_486] = [__v_2, __v_4]; - record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_487] = [__v_2, __v_4]; + record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_486] = [__v_0, __v_1]; - record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_487] = [__v_0, __v_1]; + record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_487: usize = 1; -const IN_487: usize = 1; -const OUT_487: usize = 2; -fn aiur_fn_487( - inp: [G; IN_487], +const INPUT_SIZE_488: usize = 1; +const IN_488: usize = 1; +const OUT_488: usize = 2; +fn aiur_fn_488( + inp: [G; IN_488], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_487], ExecError> { +) -> Result<[G; OUT_488], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_487] = [__v_0, __v_1]; - record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_488] = [__v_0, __v_1]; + record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_488: usize = 2; -const IN_488: usize = 2; -const OUT_488: usize = 1; -fn aiur_fn_488( - inp: [G; IN_488], +const INPUT_SIZE_489: usize = 2; +const IN_489: usize = 2; +const OUT_489: usize = 1; +fn aiur_fn_489( + inp: [G; IN_489], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_488], ExecError> { +) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41059,51 +41139,51 @@ fn aiur_fn_488( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_488] = [__v_80]; - record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_489] = [__v_80]; + record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_489: usize = 8; -const IN_489: usize = 8; -const OUT_489: usize = 1; -fn aiur_fn_489( - inp: [G; IN_489], +const INPUT_SIZE_490: usize = 8; +const IN_490: usize = 8; +const OUT_490: usize = 1; +fn aiur_fn_490( + inp: [G; IN_490], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_489], 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]; @@ -41131,23 +41211,23 @@ fn aiur_fn_489( 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_481] = { let __args: [G; IN_481] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_26]; - record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_490] = [__v_26]; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_490: usize = 2; -const IN_490: usize = 2; -const OUT_490: usize = 1; -fn aiur_fn_490( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_490], ExecError> { +) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41159,8 +41239,8 @@ fn aiur_fn_490( match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_490] = [__v_6]; - record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_6]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -41170,15 +41250,15 @@ fn aiur_fn_490( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); - let __ret: [G; OUT_490] = [__v_8]; - record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_8]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_7]; - record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_491] = [__v_7]; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41190,15 +41270,15 @@ fn aiur_fn_490( }) } -const INPUT_SIZE_491: usize = 3; -const IN_491: usize = 3; -const OUT_491: usize = 2; -fn aiur_fn_491( - inp: [G; IN_491], +const INPUT_SIZE_492: usize = 3; +const IN_492: usize = 3; +const OUT_492: usize = 2; +fn aiur_fn_492( + inp: [G; IN_492], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_491], 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]; @@ -41207,37 +41287,37 @@ fn aiur_fn_491( let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_491] = [__v_4, __v_5]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_4, __v_5]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __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_488] = { let __args: [G; IN_488] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_491] = [__v_7, __v_8]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_7, __v_8]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_491] = [__v_6, __v_7]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_6, __v_7]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41245,19 +41325,19 @@ fn aiur_fn_491( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_491] = [__v_6, __v_7]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_6, __v_7]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_491] = [__v_6, __v_7]; - record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_492] = [__v_6, __v_7]; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41268,15 +41348,15 @@ fn aiur_fn_491( }) } -const INPUT_SIZE_492: usize = 2; -const IN_492: usize = 2; -const OUT_492: usize = 1; -fn aiur_fn_492( - inp: [G; IN_492], +const INPUT_SIZE_493: usize = 2; +const IN_493: usize = 2; +const OUT_493: usize = 1; +fn aiur_fn_493( + inp: [G; IN_493], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_492], 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]; @@ -41293,14 +41373,14 @@ fn aiur_fn_492( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41313,21 +41393,21 @@ fn aiur_fn_492( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41340,31 +41420,31 @@ fn aiur_fn_492( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_492] = [__v_10]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_10]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41377,37 +41457,37 @@ fn aiur_fn_492( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_492] = [__v_10]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_10]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -41422,16 +41502,16 @@ fn aiur_fn_492( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_492] = [__v_8]; - record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_493] = [__v_8]; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41443,15 +41523,15 @@ fn aiur_fn_492( }) } -const INPUT_SIZE_493: usize = 2; -const IN_493: usize = 2; -const OUT_493: usize = 1; -fn aiur_fn_493( - inp: [G; IN_493], +const INPUT_SIZE_494: usize = 2; +const IN_494: usize = 2; +const OUT_494: usize = 1; +fn aiur_fn_494( + inp: [G; IN_494], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_493], 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]; @@ -41468,14 +41548,14 @@ fn aiur_fn_493( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_8]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_8]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41488,19 +41568,19 @@ fn aiur_fn_493( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_493] = [__v_8]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_8]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_10]; - record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_494] = [__v_10]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -41515,15 +41595,15 @@ fn aiur_fn_493( }) } -const INPUT_SIZE_494: usize = 4; -const IN_494: usize = 4; -const OUT_494: usize = 1; -fn aiur_fn_494( - inp: [G; IN_494], +const INPUT_SIZE_495: usize = 4; +const IN_495: usize = 4; +const OUT_495: usize = 1; +fn aiur_fn_495( + inp: [G; IN_495], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_494], 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]; @@ -41533,16 +41613,16 @@ fn aiur_fn_494( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_494] = [__v_4]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_495] = [__v_4]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_494] = [__v_4]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_495] = [__v_4]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -41554,15 +41634,15 @@ fn aiur_fn_494( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_494] = [__v_4]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_495] = [__v_4]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_494] = [__v_4]; - record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_495] = [__v_4]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -41577,15 +41657,15 @@ fn aiur_fn_494( }) } -const INPUT_SIZE_495: usize = 2; -const IN_495: usize = 2; -const OUT_495: usize = 1; -fn aiur_fn_495( - inp: [G; IN_495], +const INPUT_SIZE_496: usize = 2; +const IN_496: usize = 2; +const OUT_496: usize = 1; +fn aiur_fn_496( + inp: [G; IN_496], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_495], 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]; @@ -41593,38 +41673,38 @@ fn aiur_fn_495( let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_495] = [__v_7]; - record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_496] = [__v_7]; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_495] = [__v_6]; - record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_496] = [__v_6]; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_496: usize = 2; -const IN_496: usize = 2; -const OUT_496: usize = 1; -fn aiur_fn_496( - inp: [G; IN_496], +const INPUT_SIZE_497: usize = 2; +const IN_497: usize = 2; +const OUT_497: usize = 1; +fn aiur_fn_497( + inp: [G; IN_497], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_496], 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]; @@ -41642,8 +41722,8 @@ fn aiur_fn_496( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_496] = [__v_12]; - record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_497] = [__v_12]; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -41660,14 +41740,14 @@ fn aiur_fn_496( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_496] = [__v_24]; - record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_497] = [__v_24]; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -41682,15 +41762,15 @@ fn aiur_fn_496( }) } -const INPUT_SIZE_497: usize = 16; -const IN_497: usize = 16; -const OUT_497: usize = 1; -fn aiur_fn_497( - inp: [G; IN_497], +const INPUT_SIZE_498: usize = 16; +const IN_498: usize = 16; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: [G; IN_498], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_497], 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]; @@ -41708,51 +41788,51 @@ fn aiur_fn_497( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_497] = [__v_30]; - record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_498] = [__v_30]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -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_499: usize = 2; +const IN_499: usize = 2; +const OUT_499: usize = 1; +fn aiur_fn_499( + inp: [G; IN_499], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_498], 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]; @@ -41769,14 +41849,14 @@ fn aiur_fn_498( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_498] = [__v_8]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_8]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_498] = [__v_8]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_8]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41789,19 +41869,19 @@ fn aiur_fn_498( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_498] = [__v_8]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_8]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_498] = [__v_10]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_10]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -41816,15 +41896,15 @@ fn aiur_fn_498( }) } -const INPUT_SIZE_499: usize = 3; -const IN_499: usize = 3; -const OUT_499: usize = 2; -fn aiur_fn_499( - inp: [G; IN_499], +const INPUT_SIZE_500: usize = 3; +const IN_500: usize = 3; +const OUT_500: usize = 2; +fn aiur_fn_500( + inp: [G; IN_500], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_499], 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]; @@ -41832,11 +41912,11 @@ fn aiur_fn_499( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_499] = [__v_4, __v_5]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_4, __v_5]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -41850,26 +41930,26 @@ fn aiur_fn_499( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_499] = [__v_12, __v_13]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_12, __v_13]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_500: usize = 9; -const IN_500: usize = 9; -const OUT_500: usize = 2; -fn aiur_fn_500( - inp: [G; IN_500], +const INPUT_SIZE_501: usize = 9; +const IN_501: usize = 9; +const OUT_501: usize = 2; +fn aiur_fn_501( + inp: [G; IN_501], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_500], 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]; @@ -41884,21 +41964,21 @@ fn aiur_fn_500( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_10, __v_11]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_10, __v_11]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41906,29 +41986,29 @@ fn aiur_fn_500( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_10, __v_11]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_10, __v_11]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41936,43 +42016,43 @@ fn aiur_fn_500( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_14, __v_15]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_14, __v_15]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -41980,49 +42060,49 @@ fn aiur_fn_500( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_13, __v_14]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_13, __v_14]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42030,57 +42110,57 @@ fn aiur_fn_500( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_13, __v_14]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_13, __v_14]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42088,65 +42168,65 @@ fn aiur_fn_500( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_13, __v_14]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_13, __v_14]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42154,79 +42234,79 @@ fn aiur_fn_500( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_17, __v_18]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_17, __v_18]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42234,29 +42314,29 @@ fn aiur_fn_500( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_10, __v_11]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_10, __v_11]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42264,33 +42344,33 @@ fn aiur_fn_500( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_18, __v_19]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_18, __v_19]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_500] = [__v_9, __v_10]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_9, __v_10]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42302,15 +42382,15 @@ fn aiur_fn_500( }) } -const INPUT_SIZE_501: usize = 7; -const IN_501: usize = 7; -const OUT_501: usize = 2; -fn aiur_fn_501( - inp: [G; IN_501], +const INPUT_SIZE_502: usize = 7; +const IN_502: usize = 7; +const OUT_502: usize = 2; +fn aiur_fn_502( + inp: [G; IN_502], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_501], 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]; @@ -42323,19 +42403,19 @@ fn aiur_fn_501( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_501] = [__v_12, __v_13]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_12, __v_13]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42344,15 +42424,15 @@ fn aiur_fn_501( }) } -const INPUT_SIZE_502: usize = 3; -const IN_502: usize = 3; -const OUT_502: usize = 2; -fn aiur_fn_502( - inp: [G; IN_502], +const INPUT_SIZE_503: usize = 3; +const IN_503: usize = 3; +const OUT_503: usize = 2; +fn aiur_fn_503( + inp: [G; IN_503], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_502], 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]; @@ -42373,19 +42453,19 @@ fn aiur_fn_502( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_502] = [__v_13, __v_14]; - record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_13, __v_14]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_502] = [__v_13, __v_14]; - record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_13, __v_14]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42399,25 +42479,25 @@ fn aiur_fn_502( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_502] = [__v_13, __v_14]; - record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_13, __v_14]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_502] = [__v_17, __v_18]; - record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_17, __v_18]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -42432,15 +42512,15 @@ fn aiur_fn_502( }) } -const INPUT_SIZE_503: usize = 12; -const IN_503: usize = 12; -const OUT_503: usize = 1; -fn aiur_fn_503( - inp: [G; IN_503], +const INPUT_SIZE_504: usize = 12; +const IN_504: usize = 12; +const OUT_504: usize = 1; +fn aiur_fn_504( + inp: [G; IN_504], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_503], 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]; @@ -42457,50 +42537,50 @@ fn aiur_fn_503( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); - let __ret: [G; OUT_503] = [__v_12]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_12]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -42510,15 +42590,15 @@ fn aiur_fn_503( }) } -const INPUT_SIZE_504: usize = 25; -const IN_504: usize = 25; -const OUT_504: usize = 2; -fn aiur_fn_504( - inp: [G; IN_504], +const INPUT_SIZE_505: usize = 25; +const IN_505: usize = 25; +const OUT_505: usize = 2; +fn aiur_fn_505( + inp: [G; IN_505], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_504], 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]; @@ -42545,42 +42625,42 @@ fn aiur_fn_504( let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_504] = [__v_28, __v_29]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_28, __v_29]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_504] = [__v_28, __v_29]; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = [__v_28, __v_29]; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_505: usize = 25; -const IN_505: usize = 25; -const OUT_505: usize = 2; -fn aiur_fn_505( - inp: [G; IN_505], +const INPUT_SIZE_506: usize = 25; +const IN_506: usize = 25; +const OUT_506: usize = 2; +fn aiur_fn_506( + inp: [G; IN_506], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_505], ExecError> { +) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42611,33 +42691,33 @@ fn aiur_fn_505( 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_34, __v_35]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_34, __v_35]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_25, __v_26]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_25, __v_26]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42645,75 +42725,75 @@ fn aiur_fn_505( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __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_506] = { let __args: [G; IN_506] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_51, __v_52]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_51, __v_52]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_46, __v_47]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_46, __v_47]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_25, __v_26]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_25, __v_26]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -42721,98 +42801,98 @@ fn aiur_fn_505( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_59, __v_60]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_59, __v_60]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_25, __v_26]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_25, __v_26]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_505] = [__v_25, __v_26]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_25, __v_26]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_506: usize = 7; -const IN_506: usize = 7; -const OUT_506: usize = 2; -fn aiur_fn_506( - inp: [G; IN_506], +const INPUT_SIZE_507: usize = 7; +const IN_507: usize = 7; +const OUT_507: usize = 2; +fn aiur_fn_507( + inp: [G; IN_507], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_506], ExecError> { +) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42824,11 +42904,11 @@ fn aiur_fn_506( let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_8, __v_9]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_8, __v_9]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -42862,34 +42942,34 @@ fn aiur_fn_506( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_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_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __ret: [G; OUT_506] = [__v_40, __v_41]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_40, __v_41]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_507: usize = 25; -const IN_507: usize = 25; -const OUT_507: usize = 2; -fn aiur_fn_507( - inp: [G; IN_507], +const INPUT_SIZE_508: usize = 25; +const IN_508: usize = 25; +const OUT_508: usize = 2; +fn aiur_fn_508( + inp: [G; IN_508], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_507], ExecError> { +) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42920,88 +43000,88 @@ fn aiur_fn_507( 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_507] = [__v_45, __v_46]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_508] = [__v_45, __v_46]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_507] = [__v_28, __v_29]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_508] = [__v_28, __v_29]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_507] = [__v_28, __v_29]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_508] = [__v_28, __v_29]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_508: usize = 3; -const IN_508: usize = 3; -const OUT_508: usize = 1; -fn aiur_fn_508( - inp: [G; IN_508], +const INPUT_SIZE_509: usize = 3; +const IN_509: usize = 3; +const OUT_509: usize = 1; +fn aiur_fn_509( + inp: [G; IN_509], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_508], ExecError> { +) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43042,25 +43122,25 @@ fn aiur_fn_508( let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_508] = [__v_34]; - record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_509] = [__v_34]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_509: usize = 2; -const IN_509: usize = 2; -const OUT_509: usize = 12; -fn aiur_fn_509( - inp: [G; IN_509], +const INPUT_SIZE_510: usize = 2; +const IN_510: usize = 2; +const OUT_510: usize = 12; +fn aiur_fn_510( + inp: [G; IN_510], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_509], ExecError> { +) -> Result<[G; OUT_510], 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_719] = { let __args: [G; IN_719] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -43077,25 +43157,25 @@ fn aiur_fn_509( let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; - let __ret: [G; OUT_509] = [__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[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_510] = [__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[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_510: usize = 2; -const IN_510: usize = 2; -const OUT_510: usize = 1; -fn aiur_fn_510( - inp: [G; IN_510], +const INPUT_SIZE_511: usize = 2; +const IN_511: usize = 2; +const OUT_511: usize = 1; +fn aiur_fn_511( + inp: [G; IN_511], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_510], ExecError> { +) -> Result<[G; OUT_511], 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_509] = { let __args: [G; IN_509] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -43110,53 +43190,53 @@ fn aiur_fn_510( let __v_13: G = __r_arr[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_510] = [__v_7]; - record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_511] = [__v_7]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_510] = [__v_14]; - record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_511] = [__v_14]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_511: usize = 3; -const IN_511: usize = 3; -const OUT_511: usize = 1; -fn aiur_fn_511( - inp: [G; IN_511], +const INPUT_SIZE_512: usize = 3; +const IN_512: usize = 3; +const OUT_512: usize = 1; +fn aiur_fn_512( + inp: [G; IN_512], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_511], ExecError> { +) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_511] = [__v_5]; - record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_512] = [__v_5]; + record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_512: usize = 5; -const IN_512: usize = 5; -const OUT_512: usize = 1; -fn aiur_fn_512( - inp: [G; IN_512], +const INPUT_SIZE_513: usize = 5; +const IN_513: usize = 5; +const OUT_513: usize = 1; +fn aiur_fn_513( + inp: [G; IN_513], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_512], ExecError> { +) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43172,23 +43252,23 @@ fn aiur_fn_512( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_512] = [__v_10]; - record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_513] = [__v_10]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __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_512] = { let __args: [G; IN_512] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_512] = [__v_14]; - record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_513] = [__v_14]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -43198,15 +43278,15 @@ fn aiur_fn_512( }) } -const INPUT_SIZE_513: usize = 5; -const IN_513: usize = 5; -const OUT_513: usize = 2; -fn aiur_fn_513( - inp: [G; IN_513], +const INPUT_SIZE_514: usize = 5; +const IN_514: usize = 5; +const OUT_514: usize = 2; +fn aiur_fn_514( + inp: [G; IN_514], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_513], ExecError> { +) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43223,35 +43303,35 @@ fn aiur_fn_513( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_513] = [__v_10, __v_11]; - record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_514] = [__v_10, __v_11]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_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_513] = [__v_16, __v_10]; - record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_514] = [__v_16, __v_10]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_513] = [__v_16, __v_9]; - record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_514] = [__v_16, __v_9]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -43263,15 +43343,15 @@ fn aiur_fn_513( }) } -const INPUT_SIZE_514: usize = 5; -const IN_514: usize = 5; -const OUT_514: usize = 1; -fn aiur_fn_514( - inp: [G; IN_514], +const INPUT_SIZE_515: usize = 5; +const IN_515: usize = 5; +const OUT_515: usize = 1; +fn aiur_fn_515( + inp: [G; IN_515], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_514], ExecError> { +) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43284,37 +43364,37 @@ fn aiur_fn_514( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_514] = [__v_8]; - record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_515] = [__v_8]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __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_514] = { let __args: [G; IN_514] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_514] = [__v_12]; - record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_515] = [__v_12]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_515: usize = 3; -const IN_515: usize = 3; -const OUT_515: usize = 1; -fn aiur_fn_515( - inp: [G; IN_515], +const INPUT_SIZE_516: usize = 3; +const IN_516: usize = 3; +const OUT_516: usize = 1; +fn aiur_fn_516( + inp: [G; IN_516], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_515], ExecError> { +) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43325,26 +43405,26 @@ fn aiur_fn_515( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_515] = [__v_11]; - record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_516] = [__v_11]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_516: usize = 4; -const IN_516: usize = 4; -const OUT_516: usize = 1; -fn aiur_fn_516( - inp: [G; IN_516], +const INPUT_SIZE_517: usize = 4; +const IN_517: usize = 4; +const OUT_517: usize = 1; +fn aiur_fn_517( + inp: [G; IN_517], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_516], ExecError> { +) -> Result<[G; OUT_517], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43352,30 +43432,30 @@ fn aiur_fn_516( let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_516] = [__v_0]; - record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_517] = [__v_0]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_516] = [__v_0]; - record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_517] = [__v_0]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_516] = [__v_9]; - record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_517] = [__v_9]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -43384,15 +43464,15 @@ fn aiur_fn_516( }) } -const INPUT_SIZE_517: usize = 3; -const IN_517: usize = 3; -const OUT_517: usize = 1; -fn aiur_fn_517( - inp: [G; IN_517], +const INPUT_SIZE_518: usize = 3; +const IN_518: usize = 3; +const OUT_518: usize = 1; +fn aiur_fn_518( + inp: [G; IN_518], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_517], ExecError> { +) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43406,19 +43486,19 @@ fn aiur_fn_517( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_8]; - record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_518] = [__v_8]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_517] = [__v_8]; - record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_518] = [__v_8]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -43428,28 +43508,28 @@ fn aiur_fn_517( }) } -const INPUT_SIZE_518: usize = 3; -const IN_518: usize = 3; -const OUT_518: usize = 1; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_519: usize = 3; +const IN_519: usize = 3; +const OUT_519: usize = 1; +fn aiur_fn_519( + inp: [G; IN_519], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_518], ExecError> { +) -> Result<[G; OUT_519], ExecError> { stacker::maybe_grow(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_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_6]; - record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_519] = [__v_6]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -43458,32 +43538,32 @@ fn aiur_fn_518( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_8]; - record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_519] = [__v_8]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_518] = [__v_5]; - record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_519] = [__v_5]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_519: usize = 3; -const IN_519: usize = 3; -const OUT_519: usize = 1; -fn aiur_fn_519( - inp: [G; IN_519], +const INPUT_SIZE_520: usize = 3; +const IN_520: usize = 3; +const OUT_520: usize = 1; +fn aiur_fn_520( + inp: [G; IN_520], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_519], ExecError> { +) -> Result<[G; OUT_520], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43497,17 +43577,17 @@ fn aiur_fn_519( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_8]; - record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_520] = [__v_8]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_519] = [__v_7]; - record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_520] = [__v_7]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -43517,15 +43597,15 @@ fn aiur_fn_519( }) } -const INPUT_SIZE_520: usize = 4; -const IN_520: usize = 4; -const OUT_520: usize = 1; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_521: usize = 4; +const IN_521: usize = 4; +const OUT_521: usize = 1; +fn aiur_fn_521( + inp: [G; IN_521], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_520], ExecError> { +) -> Result<[G; OUT_521], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43542,12 +43622,12 @@ fn aiur_fn_520( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_11]; - record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_521] = [__v_11]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -43560,7 +43640,7 @@ fn aiur_fn_520( 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_509] = { let __args: [G; IN_509] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -43573,24 +43653,24 @@ fn aiur_fn_520( 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_504] = { let __args: [G; IN_504] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_34]; - record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_521] = [__v_34]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_35]; - record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_521] = [__v_35]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -43602,15 +43682,15 @@ fn aiur_fn_520( }) } -const INPUT_SIZE_521: usize = 3; -const IN_521: usize = 3; -const OUT_521: usize = 1; -fn aiur_fn_521( - inp: [G; IN_521], +const INPUT_SIZE_522: usize = 3; +const IN_522: usize = 3; +const OUT_522: usize = 1; +fn aiur_fn_522( + inp: [G; IN_522], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_521], ExecError> { +) -> Result<[G; OUT_522], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43624,8 +43704,8 @@ fn aiur_fn_521( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_8]; - record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_522] = [__v_8]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -43634,10 +43714,10 @@ fn aiur_fn_521( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_521] = [__v_11]; - record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_522] = [__v_11]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -43647,15 +43727,15 @@ fn aiur_fn_521( }) } -const INPUT_SIZE_522: usize = 5; -const IN_522: usize = 5; -const OUT_522: usize = 1; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_523: usize = 5; +const IN_523: usize = 5; +const OUT_523: usize = 1; +fn aiur_fn_523( + inp: [G; IN_523], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_522], 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]; @@ -43673,12 +43753,12 @@ fn aiur_fn_522( let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_12]; - record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_12]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -43691,7 +43771,7 @@ fn aiur_fn_522( 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_509] = { let __args: [G; IN_509] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -43704,17 +43784,17 @@ fn aiur_fn_522( 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_504] = { let __args: [G; IN_504] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __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_710] = { let __args: [G; IN_710] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __ret: [G; OUT_522] = [__v_35]; - record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_35]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -43724,11 +43804,11 @@ fn aiur_fn_522( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_41]; - record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_41]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -43740,15 +43820,15 @@ fn aiur_fn_522( }) } -const INPUT_SIZE_523: usize = 2; -const IN_523: usize = 2; -const OUT_523: usize = 1; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_524: usize = 2; +const IN_524: usize = 2; +const OUT_524: usize = 1; +fn aiur_fn_524( + inp: [G; IN_524], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_523], 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]; @@ -43765,14 +43845,14 @@ fn aiur_fn_523( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_523] = [__v_8]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_8]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_523] = [__v_8]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_8]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -43785,25 +43865,25 @@ fn aiur_fn_523( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_523] = [__v_8]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_8]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_523] = [__v_9]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_9]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_523] = [__v_9]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_9]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -43820,15 +43900,15 @@ fn aiur_fn_523( }) } -const INPUT_SIZE_524: usize = 1; -const IN_524: usize = 1; -const OUT_524: usize = 1; -fn aiur_fn_524( - inp: [G; IN_524], +const INPUT_SIZE_525: usize = 1; +const IN_525: usize = 1; +const OUT_525: usize = 1; +fn aiur_fn_525( + inp: [G; IN_525], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_524], ExecError> { +) -> Result<[G; OUT_525], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -43840,17 +43920,17 @@ fn aiur_fn_524( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_6]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_525] = [__v_6]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_524] = [__v_5]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_525] = [__v_5]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -43860,15 +43940,15 @@ fn aiur_fn_524( }) } -const INPUT_SIZE_525: usize = 1; -const IN_525: usize = 1; -const OUT_525: usize = 1; -fn aiur_fn_525( - inp: [G; IN_525], +const INPUT_SIZE_526: usize = 1; +const IN_526: usize = 1; +const OUT_526: usize = 1; +fn aiur_fn_526( + inp: [G; IN_526], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_525], ExecError> { +) -> Result<[G; OUT_526], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -43878,25 +43958,25 @@ fn aiur_fn_525( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_525] = [__v_4]; - record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_526] = [__v_4]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_525] = [__v_5]; - record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_526] = [__v_5]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_525] = [__v_5]; - record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_526] = [__v_5]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -43908,15 +43988,15 @@ fn aiur_fn_525( }) } -const INPUT_SIZE_526: usize = 2; -const IN_526: usize = 2; -const OUT_526: usize = 1; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_527: usize = 2; +const IN_527: usize = 2; +const OUT_527: usize = 1; +fn aiur_fn_527( + inp: [G; IN_527], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_526], 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]; @@ -43973,26 +44053,26 @@ fn aiur_fn_526( let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_526] = [__v_51]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_51]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!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_526] = { let __args: [G; IN_526] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_526] = [__v_53]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_53]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_526] = [__v_51]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_51]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -44004,15 +44084,15 @@ fn aiur_fn_526( }) } -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_528: usize = 2; +const IN_528: usize = 2; +const OUT_528: usize = 1; +fn aiur_fn_528( + inp: [G; IN_528], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_527], 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]; @@ -44067,8 +44147,8 @@ fn aiur_fn_527( match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_527] = [__v_49]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = [__v_49]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -44094,15 +44174,15 @@ fn aiur_fn_527( match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); - let __ret: [G; OUT_527] = [__v_50]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = [__v_50]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_527] = [__v_50]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = [__v_50]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -44114,15 +44194,15 @@ fn aiur_fn_527( }) } -const INPUT_SIZE_528: usize = 1; -const IN_528: usize = 1; -const OUT_528: usize = 0; -fn aiur_fn_528( - inp: [G; IN_528], +const INPUT_SIZE_529: usize = 1; +const IN_529: usize = 1; +const OUT_529: usize = 0; +fn aiur_fn_529( + inp: [G; IN_529], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_528], ExecError> { +) -> Result<[G; OUT_529], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; @@ -44179,57 +44259,57 @@ fn aiur_fn_528( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __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_717] = { let __args: [G; IN_717] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_59.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_528] = []; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = []; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_50, __v_60, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_50, __v_60, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = G::from_u64(1); if (__v_62 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_64, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_64, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); if (__v_65 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } - let __ret: [G; OUT_528] = []; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = []; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_528] = []; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = []; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -44238,15 +44318,15 @@ fn aiur_fn_528( }) } -const INPUT_SIZE_529: usize = 12; -const IN_529: usize = 12; -const OUT_529: usize = 1; -fn aiur_fn_529( - inp: [G; IN_529], +const INPUT_SIZE_530: usize = 12; +const IN_530: usize = 12; +const OUT_530: usize = 1; +fn aiur_fn_530( + inp: [G; IN_530], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_529], 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]; @@ -44262,56 +44342,56 @@ fn aiur_fn_529( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_529] = [__v_3]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_3]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_529] = [__v_12]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_12]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_529] = [__v_12]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_12]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_529] = [__v_12]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_12]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_529] = [__v_4]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_4]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_529] = [__v_12]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_12]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_529] = [__v_6]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_6]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_529] = [__v_8]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_8]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_529] = [__v_9]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_9]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44321,15 +44401,15 @@ fn aiur_fn_529( }) } -const INPUT_SIZE_530: usize = 1; -const IN_530: usize = 1; -const OUT_530: usize = 1; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_531: usize = 1; +const IN_531: usize = 1; +const OUT_531: usize = 1; +fn aiur_fn_531( + inp: [G; IN_531], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_530], ExecError> { +) -> Result<[G; OUT_531], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -44340,14 +44420,14 @@ fn aiur_fn_530( match __v_1.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_530] = [__v_5]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_5]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_530] = [__v_5]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_5]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { @@ -44367,67 +44447,67 @@ fn aiur_fn_530( 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_529] = { let __args: [G; IN_529] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_530] = [__v_20]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_20]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_530] = [__v_7]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_7]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_530] = [__v_7]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_7]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_530] = [__v_7]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_7]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __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_530] = [__v_9]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_9]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_530] = [__v_5]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_5]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_530] = [__v_5]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_5]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44437,48 +44517,48 @@ fn aiur_fn_530( }) } -const INPUT_SIZE_531: usize = 2; -const IN_531: usize = 2; -const OUT_531: usize = 0; -fn aiur_fn_531( - inp: [G; IN_531], +const INPUT_SIZE_532: usize = 2; +const IN_532: usize = 2; +const OUT_532: usize = 0; +fn aiur_fn_532( + inp: [G; IN_532], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_531], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_531] = []; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = []; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __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_531] = []; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = []; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_532: usize = 2; -const IN_532: usize = 2; -const OUT_532: usize = 0; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_533: usize = 2; +const IN_533: usize = 2; +const OUT_533: usize = 0; +fn aiur_fn_533( + inp: [G; IN_533], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_532], 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]; @@ -44488,28 +44568,28 @@ fn aiur_fn_532( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_532] = []; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_533] = []; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_532] = []; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_533] = []; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_532] = []; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_533] = []; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_532] = []; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_533] = []; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { @@ -44518,8 +44598,8 @@ fn aiur_fn_532( 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_532] = []; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_533] = []; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44529,15 +44609,15 @@ fn aiur_fn_532( }) } -const INPUT_SIZE_533: usize = 2; -const IN_533: usize = 2; -const OUT_533: usize = 0; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_534: usize = 2; +const IN_534: usize = 2; +const OUT_534: usize = 0; +fn aiur_fn_534( + inp: [G; IN_534], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_533], 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]; @@ -44547,15 +44627,15 @@ fn aiur_fn_533( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_533] = []; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_533] = []; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_534] = []; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44565,15 +44645,15 @@ fn aiur_fn_533( }) } -const INPUT_SIZE_534: usize = 3; -const IN_534: usize = 3; -const OUT_534: usize = 0; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_535: usize = 3; +const IN_535: usize = 3; +const OUT_535: usize = 0; +fn aiur_fn_535( + inp: [G; IN_535], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_534], ExecError> { +) -> Result<[G; OUT_535], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44590,14 +44670,14 @@ fn aiur_fn_534( 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_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { @@ -44616,62 +44696,62 @@ fn aiur_fn_534( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_533] = { let __args: [G; IN_533] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_534] = []; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_535] = []; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44681,15 +44761,15 @@ fn aiur_fn_534( }) } -const INPUT_SIZE_535: usize = 0; -const IN_535: usize = 0; -const OUT_535: usize = 1; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_536: usize = 0; +const IN_536: usize = 0; +const OUT_536: usize = 1; +fn aiur_fn_536( + inp: [G; IN_536], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_535], ExecError> { +) -> Result<[G; OUT_536], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(104); @@ -44724,21 +44804,21 @@ fn aiur_fn_535( let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(184); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_535] = [__v_32]; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_32]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_536: usize = 3; -const IN_536: usize = 3; -const OUT_536: usize = 1; -fn aiur_fn_536( - inp: [G; IN_536], +const INPUT_SIZE_537: usize = 3; +const IN_537: usize = 3; +const OUT_537: usize = 1; +fn aiur_fn_537( + inp: [G; IN_537], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_536], ExecError> { +) -> Result<[G; OUT_537], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44747,8 +44827,8 @@ fn aiur_fn_536( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_536] = [__v_4]; - record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_537] = [__v_4]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44761,16 +44841,16 @@ fn aiur_fn_536( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_536] = [__v_10]; - record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_537] = [__v_10]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_536] = [__v_8]; - record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_537] = [__v_8]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -44779,15 +44859,15 @@ fn aiur_fn_536( }) } -const INPUT_SIZE_537: usize = 0; -const IN_537: usize = 0; -const OUT_537: usize = 0; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_538: usize = 0; +const IN_538: usize = 0; +const OUT_538: usize = 0; +fn aiur_fn_538( + inp: [G; IN_538], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_537], ExecError> { +) -> Result<[G; OUT_538], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(3); let __v_1: G = G::from_u64(107); @@ -44851,8 +44931,8 @@ fn aiur_fn_537( if (__v_39 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } - let __ret: [G; OUT_537] = []; - record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_538] = []; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44862,15 +44942,15 @@ fn aiur_fn_537( }) } -const INPUT_SIZE_538: usize = 4; -const IN_538: usize = 4; -const OUT_538: usize = 0; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_539: usize = 4; +const IN_539: usize = 4; +const OUT_539: usize = 0; +fn aiur_fn_539( + inp: [G; IN_539], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_538], ExecError> { +) -> Result<[G; OUT_539], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44878,7 +44958,7 @@ fn aiur_fn_538( let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -44891,7 +44971,7 @@ fn aiur_fn_538( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -44904,8 +44984,8 @@ fn aiur_fn_538( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -44918,7 +44998,7 @@ fn aiur_fn_538( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -44941,34 +45021,34 @@ fn aiur_fn_538( 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_536] = { let __args: [G; IN_536] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __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_538] = []; - record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_539] = []; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -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_540: usize = 2; +const IN_540: usize = 2; +const OUT_540: usize = 1; +fn aiur_fn_540( + inp: [G; IN_540], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_539] = [__v_0]; - record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_540] = [__v_0]; + record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44981,10 +45061,10 @@ fn aiur_fn_539( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_8]; - record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_540] = [__v_8]; + record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44996,29 +45076,29 @@ fn aiur_fn_539( }) } -const INPUT_SIZE_540: usize = 3; -const IN_540: usize = 3; -const OUT_540: usize = 0; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_541: usize = 3; +const IN_541: usize = 3; +const OUT_541: usize = 0; +fn aiur_fn_541( + inp: [G; IN_541], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_540], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_540] = []; - record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_541] = []; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45038,12 +45118,12 @@ fn aiur_fn_540( 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_540] = { let __args: [G; IN_540] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; 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_540] = []; - record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_541] = []; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45060,15 +45140,15 @@ fn aiur_fn_540( }) } -const INPUT_SIZE_541: usize = 4; -const IN_541: usize = 4; -const OUT_541: usize = 0; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_542: usize = 4; +const IN_542: usize = 4; +const OUT_542: usize = 0; +fn aiur_fn_542( + inp: [G; IN_542], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_541], 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]; @@ -45077,8 +45157,8 @@ fn aiur_fn_541( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_541] = []; - record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_542] = []; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45097,7 +45177,7 @@ fn aiur_fn_541( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -45105,8 +45185,8 @@ fn aiur_fn_541( 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_541] = []; - record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_542] = []; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45123,15 +45203,15 @@ fn aiur_fn_541( }) } -const INPUT_SIZE_542: usize = 3; -const IN_542: usize = 3; -const OUT_542: usize = 0; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_543: usize = 3; +const IN_543: usize = 3; +const OUT_543: usize = 0; +fn aiur_fn_543( + inp: [G; IN_543], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_542], 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]; @@ -45162,8 +45242,8 @@ fn aiur_fn_542( 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_542] = []; - record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_543] = []; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45173,15 +45253,15 @@ fn aiur_fn_542( }) } -const INPUT_SIZE_543: usize = 7; -const IN_543: usize = 7; -const OUT_543: usize = 0; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_544: usize = 7; +const IN_544: usize = 7; +const OUT_544: usize = 0; +fn aiur_fn_544( + inp: [G; IN_544], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_543], 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]; @@ -45191,7 +45271,7 @@ fn aiur_fn_543( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -45203,32 +45283,32 @@ fn aiur_fn_543( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_554] = { let __args: [G; IN_554] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __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_543] = []; - record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_544] = []; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45238,15 +45318,15 @@ fn aiur_fn_543( }) } -const INPUT_SIZE_544: usize = 4; -const IN_544: usize = 4; -const OUT_544: usize = 0; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_545: usize = 4; +const IN_545: usize = 4; +const OUT_545: usize = 0; +fn aiur_fn_545( + inp: [G; IN_545], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_544], 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]; @@ -45254,8 +45334,8 @@ fn aiur_fn_544( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_544] = []; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_545] = []; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45273,7 +45353,7 @@ fn aiur_fn_544( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -45283,9 +45363,9 @@ fn aiur_fn_544( } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 - __v_16); - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_544] = []; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_545] = []; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45302,15 +45382,15 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 3; -const IN_545: usize = 3; -const OUT_545: usize = 0; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_546: usize = 3; +const IN_546: usize = 3; +const OUT_546: usize = 0; +fn aiur_fn_546( + inp: [G; IN_546], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_545], 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]; @@ -45318,27 +45398,27 @@ fn aiur_fn_545( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_545] = []; - record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_546] = []; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_546: usize = 3; -const IN_546: usize = 3; -const OUT_546: usize = 1; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_547: usize = 3; +const IN_547: usize = 3; +const OUT_547: usize = 1; +fn aiur_fn_547( + inp: [G; IN_547], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_546], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { @@ -45349,8 +45429,8 @@ fn aiur_fn_546( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_546] = [__v_5]; - record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_547] = [__v_5]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45370,10 +45450,10 @@ fn aiur_fn_546( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_546] = [__v_12]; - record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_547] = [__v_12]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45385,15 +45465,15 @@ fn aiur_fn_546( }) } -const INPUT_SIZE_547: usize = 3; -const IN_547: usize = 3; -const OUT_547: usize = 0; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_548: usize = 3; +const IN_548: usize = 3; +const OUT_548: usize = 0; +fn aiur_fn_548( + inp: [G; IN_548], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_547], 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]; @@ -45405,9 +45485,9 @@ fn aiur_fn_547( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { @@ -45415,29 +45495,29 @@ fn aiur_fn_547( } let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_547] = []; - record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_548] = []; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_547] = []; - record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_548] = []; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_548: usize = 4; -const IN_548: usize = 4; -const OUT_548: usize = 0; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_549: usize = 4; +const IN_549: usize = 4; +const OUT_549: usize = 0; +fn aiur_fn_549( + inp: [G; IN_549], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_548], 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]; @@ -45445,9 +45525,9 @@ fn aiur_fn_548( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_548] = []; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_549] = []; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45462,9 +45542,9 @@ fn aiur_fn_548( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_548] = []; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_549] = []; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45476,15 +45556,15 @@ fn aiur_fn_548( }) } -const INPUT_SIZE_549: usize = 3; -const IN_549: usize = 3; -const OUT_549: usize = 0; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_550: usize = 3; +const IN_550: usize = 3; +const OUT_550: usize = 0; +fn aiur_fn_550( + inp: [G; IN_550], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_549], 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]; @@ -45495,52 +45575,52 @@ fn aiur_fn_549( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_549] = []; - record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_550] = []; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_549] = []; - record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_550] = []; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_550: usize = 2; -const IN_550: usize = 2; -const OUT_550: usize = 1; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_551: usize = 2; +const IN_551: usize = 2; +const OUT_551: usize = 1; +fn aiur_fn_551( + inp: [G; IN_551], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_550], 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 __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_550] = [__v_2]; - record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_551] = [__v_2]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_551: usize = 2; -const IN_551: usize = 2; -const OUT_551: usize = 1; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_552: usize = 2; +const IN_552: usize = 2; +const OUT_552: usize = 1; +fn aiur_fn_552( + inp: [G; IN_552], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_551], 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]; @@ -45551,8 +45631,8 @@ fn aiur_fn_551( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_551] = [__v_5]; - record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_5]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -45561,15 +45641,15 @@ fn aiur_fn_551( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_551] = [__v_6]; - record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_6]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_551] = [__v_6]; - record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_6]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45581,15 +45661,15 @@ fn aiur_fn_551( }) } -const INPUT_SIZE_552: usize = 2; -const IN_552: usize = 2; -const OUT_552: usize = 1; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_553: usize = 2; +const IN_553: usize = 2; +const OUT_553: usize = 1; +fn aiur_fn_553( + inp: [G; IN_553], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_552], 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]; @@ -45610,31 +45690,31 @@ fn aiur_fn_552( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_552] = [__v_15]; - record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_15]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_552] = [__v_15]; - record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_15]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_553: usize = 2; -const IN_553: usize = 2; -const OUT_553: usize = 1; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_554: usize = 2; +const IN_554: usize = 2; +const OUT_554: usize = 1; +fn aiur_fn_554( + inp: [G; IN_554], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_553], 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]; @@ -45646,105 +45726,105 @@ fn aiur_fn_553( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_553] = [__v_6]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_6]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_553] = [__v_6]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_6]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_6]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_6]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_553] = [__v_7]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_7]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_7]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_7]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_553] = [__v_7]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_7]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_7]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_7]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_553] = [__v_7]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_7]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_7]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_7]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_553] = [__v_7]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_7]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_553] = [__v_8]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_8]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_8]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_8]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45753,15 +45833,15 @@ fn aiur_fn_553( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_553] = [__v_6]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_6]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_6]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_6]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45771,15 +45851,15 @@ fn aiur_fn_553( }) } -const INPUT_SIZE_554: usize = 2; -const IN_554: usize = 2; -const OUT_554: usize = 1; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_555: usize = 2; +const IN_555: usize = 2; +const OUT_555: usize = 1; +fn aiur_fn_555( + inp: [G; IN_555], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_554], 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]; @@ -45790,25 +45870,25 @@ fn aiur_fn_554( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_554] = [__v_5]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_5]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_554] = [__v_6]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_6]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_6]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_6]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45820,23 +45900,23 @@ fn aiur_fn_554( }) } -const INPUT_SIZE_555: usize = 3; -const IN_555: usize = 3; -const OUT_555: usize = 2; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_556: usize = 3; +const IN_556: usize = 3; +const OUT_556: usize = 2; +fn aiur_fn_556( + inp: [G; IN_556], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_555], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_555] = [__v_0, __v_2]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_0, __v_2]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45851,16 +45931,16 @@ fn aiur_fn_555( let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_555] = [__v_11, __v_12]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_11, __v_12]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_555] = [__v_0, __v_2]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_0, __v_2]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45869,15 +45949,15 @@ fn aiur_fn_555( }) } -const INPUT_SIZE_556: usize = 4; -const IN_556: usize = 4; -const OUT_556: usize = 0; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_557: usize = 4; +const IN_557: usize = 4; +const OUT_557: usize = 0; +fn aiur_fn_557( + inp: [G; IN_557], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_556], 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]; @@ -45886,8 +45966,8 @@ fn aiur_fn_556( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_556] = []; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = []; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45912,9 +45992,9 @@ fn aiur_fn_556( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_556] = []; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_557] = []; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45931,15 +46011,15 @@ fn aiur_fn_556( }) } -const INPUT_SIZE_557: usize = 5; -const IN_557: usize = 5; -const OUT_557: usize = 0; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_558: usize = 5; +const IN_558: usize = 5; +const OUT_558: usize = 0; +fn aiur_fn_558( + inp: [G; IN_558], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_557], 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]; @@ -45964,25 +46044,25 @@ fn aiur_fn_557( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_728] = { let __args: [G; IN_728] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __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_557] = []; - record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45992,30 +46072,30 @@ fn aiur_fn_557( }) } -const INPUT_SIZE_558: usize = 4; -const IN_558: usize = 4; -const OUT_558: usize = 0; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_559: usize = 4; +const IN_559: usize = 4; +const OUT_559: usize = 0; +fn aiur_fn_559( + inp: [G; IN_559], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_558], 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 __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_558] = []; - record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -46026,15 +46106,15 @@ fn aiur_fn_558( 5u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_558] = []; - record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46048,22 +46128,22 @@ fn aiur_fn_558( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __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_717] = { let __args: [G; IN_717] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_558] = []; - record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_558] = []; - record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46086,24 +46166,24 @@ fn aiur_fn_558( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __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_559] = { let __args: [G; IN_559] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_558] = []; - record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46124,15 +46204,15 @@ fn aiur_fn_558( }) } -const INPUT_SIZE_559: usize = 7; -const IN_559: usize = 7; -const OUT_559: usize = 0; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_560: usize = 7; +const IN_560: usize = 7; +const OUT_560: usize = 0; +fn aiur_fn_560( + inp: [G; IN_560], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_559], 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]; @@ -46144,8 +46224,8 @@ fn aiur_fn_559( let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_559] = []; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_560] = []; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46169,22 +46249,22 @@ fn aiur_fn_559( let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __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_338] = { let __args: [G; IN_338] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_559] = []; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_560] = []; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46196,15 +46276,15 @@ fn aiur_fn_559( }) } -const INPUT_SIZE_560: usize = 4; -const IN_560: usize = 4; -const OUT_560: usize = 0; -fn aiur_fn_560( - inp: [G; IN_560], +const INPUT_SIZE_561: usize = 4; +const IN_561: usize = 4; +const OUT_561: usize = 0; +fn aiur_fn_561( + inp: [G; IN_561], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_560], 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]; @@ -46217,32 +46297,32 @@ fn aiur_fn_560( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_560] = []; - record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_561] = []; + record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_560] = []; - record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_561] = []; + record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_561: usize = 4; -const IN_561: usize = 4; -const OUT_561: usize = 0; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_562: usize = 4; +const IN_562: usize = 4; +const OUT_562: usize = 0; +fn aiur_fn_562( + inp: [G; IN_562], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_561], 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]; @@ -46253,26 +46333,26 @@ fn aiur_fn_561( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __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_560] = { let __args: [G; IN_560] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_561] = []; - record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_562] = []; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_562: usize = 7; -const IN_562: usize = 7; -const OUT_562: usize = 0; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_563: usize = 7; +const IN_563: usize = 7; +const OUT_563: usize = 0; +fn aiur_fn_563( + inp: [G; IN_563], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_562], 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]; @@ -46285,25 +46365,25 @@ fn aiur_fn_562( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_562] = []; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_563] = []; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_563: usize = 9; -const IN_563: usize = 9; -const OUT_563: usize = 0; -fn aiur_fn_563( - inp: [G; IN_563], +const INPUT_SIZE_564: usize = 9; +const IN_564: usize = 9; +const OUT_564: usize = 0; +fn aiur_fn_564( + inp: [G; IN_564], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_563], 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]; @@ -46317,8 +46397,8 @@ fn aiur_fn_563( let __v_9: G = (__v_3 - __v_8); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_563] = []; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = []; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46339,13 +46419,13 @@ fn aiur_fn_563( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_13, __v_17, __v_2, __v_18, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_13, __v_17, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_13, __v_17, __v_2, __v_18, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_13, __v_17, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_13, __v_17, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_13, __v_17, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_14, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); @@ -46363,9 +46443,9 @@ fn aiur_fn_563( } let __v_28: G = G::from_u64(1); let __v_29: G = (__v_8 + __v_28); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_563] = []; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_564] = []; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46377,15 +46457,15 @@ fn aiur_fn_563( }) } -const INPUT_SIZE_564: usize = 12; -const IN_564: usize = 12; -const OUT_564: usize = 0; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_565: usize = 12; +const IN_565: usize = 12; +const OUT_565: usize = 0; +fn aiur_fn_565( + inp: [G; IN_565], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_564], 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]; @@ -46401,29 +46481,29 @@ fn aiur_fn_564( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_564] = []; - record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_565] = []; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_564] = []; - record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_565] = []; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_565: usize = 13; -const IN_565: usize = 13; -const OUT_565: usize = 0; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_566: usize = 13; +const IN_566: usize = 13; +const OUT_566: usize = 0; +fn aiur_fn_566( + inp: [G; IN_566], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_565], 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]; @@ -46444,8 +46524,8 @@ fn aiur_fn_565( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_565] = []; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46503,14 +46583,14 @@ fn aiur_fn_565( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_565] = []; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_565] = []; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46520,23 +46600,23 @@ fn aiur_fn_565( } }, _ => { - let __ret: [G; OUT_565] = []; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_566] = []; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_566: usize = 7; -const IN_566: usize = 7; -const OUT_566: usize = 0; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_567: usize = 7; +const IN_567: usize = 7; +const OUT_567: usize = 0; +fn aiur_fn_567( + inp: [G; IN_567], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_566], 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]; @@ -46595,8 +46675,8 @@ fn aiur_fn_566( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = []; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -46608,9 +46688,9 @@ fn aiur_fn_566( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_567] = []; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46631,23 +46711,23 @@ fn aiur_fn_566( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __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_297] = { let __args: [G; IN_297] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -46655,17 +46735,17 @@ fn aiur_fn_566( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_567] = []; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!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_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_567] = []; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46675,9 +46755,9 @@ fn aiur_fn_566( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_566] = []; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_567] = []; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46689,15 +46769,15 @@ fn aiur_fn_566( }) } -const INPUT_SIZE_567: usize = 15; -const IN_567: usize = 15; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_568: usize = 15; +const IN_568: usize = 15; +const OUT_568: usize = 1; +fn aiur_fn_568( + inp: [G; IN_568], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_567], 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]; @@ -46719,24 +46799,24 @@ fn aiur_fn_567( match __v_15.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_567] = [__v_16]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_16]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_567] = [__v_16]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_16]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_567] = [__v_16]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_16]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46745,26 +46825,26 @@ fn aiur_fn_567( match __v_10.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_567] = [__v_16]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_16]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_5, __v_9, __v_10, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_5, __v_9, __v_10, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_567] = [__v_19]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_19]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_567] = [__v_16]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_16]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46773,8 +46853,8 @@ fn aiur_fn_567( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_567] = [__v_16]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_16]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46783,15 +46863,15 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 4; -const IN_568: usize = 4; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_569: usize = 4; +const IN_569: usize = 4; +const OUT_569: usize = 1; +fn aiur_fn_569( + inp: [G; IN_569], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_568], 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]; @@ -46803,10 +46883,10 @@ fn aiur_fn_568( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_8]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_569] = [__v_8]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46821,16 +46901,16 @@ fn aiur_fn_568( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_12]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_569] = [__v_12]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_568] = [__v_8]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_569] = [__v_8]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46839,15 +46919,15 @@ fn aiur_fn_568( }) } -const INPUT_SIZE_569: usize = 5; -const IN_569: usize = 5; -const OUT_569: usize = 1; -fn aiur_fn_569( - inp: [G; IN_569], +const INPUT_SIZE_570: usize = 5; +const IN_570: usize = 5; +const OUT_570: usize = 1; +fn aiur_fn_570( + inp: [G; IN_570], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_569], 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]; @@ -46860,10 +46940,10 @@ fn aiur_fn_569( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_8]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_8]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46874,13 +46954,13 @@ fn aiur_fn_569( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -46902,16 +46982,16 @@ fn aiur_fn_569( let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_25]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_25]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_10]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_10]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46920,15 +47000,15 @@ fn aiur_fn_569( }) } -const INPUT_SIZE_570: usize = 2; -const IN_570: usize = 2; -const OUT_570: usize = 1; -fn aiur_fn_570( - inp: [G; IN_570], +const INPUT_SIZE_571: usize = 2; +const IN_571: usize = 2; +const OUT_571: usize = 1; +fn aiur_fn_571( + inp: [G; IN_571], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_570], 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]; @@ -46939,25 +47019,25 @@ fn aiur_fn_570( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_570] = [__v_5]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_5]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __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_570] = [__v_6]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_6]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_6]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_6]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46969,15 +47049,15 @@ fn aiur_fn_570( }) } -const INPUT_SIZE_571: usize = 2; -const IN_571: usize = 2; -const OUT_571: usize = 1; -fn aiur_fn_571( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_571], 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]; @@ -46988,8 +47068,8 @@ fn aiur_fn_571( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_571] = [__v_5]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_5]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -47004,24 +47084,24 @@ fn aiur_fn_571( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_571] = [__v_10]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_10]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_10]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_10]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_9]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_9]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47033,15 +47113,15 @@ fn aiur_fn_571( }) } -const INPUT_SIZE_572: usize = 13; -const IN_572: usize = 13; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +const INPUT_SIZE_573: usize = 13; +const IN_573: usize = 13; +const OUT_573: usize = 1; +fn aiur_fn_573( + inp: [G; IN_573], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_572], 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]; @@ -47058,13 +47138,13 @@ fn aiur_fn_572( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __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_572] = [__v_14]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_14]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47072,18 +47152,18 @@ fn aiur_fn_572( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_23]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_23]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47108,22 +47188,22 @@ fn aiur_fn_572( match __v_25.as_canonical_u64() { 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); - let __ret: [G; OUT_572] = [__v_37]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_37]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_37]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_37]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_23]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_23]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47134,23 +47214,23 @@ fn aiur_fn_572( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_13]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_13]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_574: usize = 2; +const IN_574: usize = 2; +const OUT_574: usize = 1; +fn aiur_fn_574( + inp: [G; IN_574], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_573], 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]; @@ -47159,8 +47239,8 @@ fn aiur_fn_573( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_573] = [__v_3]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_3]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47218,16 +47298,16 @@ fn aiur_fn_573( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_573] = [__v_52]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_52]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_51]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_51]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47238,15 +47318,15 @@ fn aiur_fn_573( }) } -const INPUT_SIZE_574: usize = 1; -const IN_574: usize = 1; -const OUT_574: usize = 1; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_575: usize = 1; +const IN_575: usize = 1; +const OUT_575: usize = 1; +fn aiur_fn_575( + inp: [G; IN_575], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_574], ExecError> { +) -> Result<[G; OUT_575], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; @@ -47303,14 +47383,14 @@ fn aiur_fn_574( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_49]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_49]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_574] = [__v_49]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_49]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47319,15 +47399,15 @@ fn aiur_fn_574( }) } -const INPUT_SIZE_575: usize = 2; -const IN_575: usize = 2; -const OUT_575: usize = 1; -fn aiur_fn_575( - inp: [G; IN_575], +const INPUT_SIZE_576: usize = 2; +const IN_576: usize = 2; +const OUT_576: usize = 1; +fn aiur_fn_576( + inp: [G; IN_576], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_575], ExecError> { +) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47384,14 +47464,14 @@ fn aiur_fn_575( match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_575] = [__v_49]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_49]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_49]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_49]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47401,17 +47481,17 @@ fn aiur_fn_575( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_575] = [__v_51]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_51]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_575] = [__v_49]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_49]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47423,15 +47503,15 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 5; -const IN_576: usize = 5; -const OUT_576: usize = 1; -fn aiur_fn_576( - inp: [G; IN_576], +const INPUT_SIZE_577: usize = 5; +const IN_577: usize = 5; +const OUT_577: usize = 1; +fn aiur_fn_577( + inp: [G; IN_577], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_576], ExecError> { +) -> Result<[G; OUT_577], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47441,7 +47521,7 @@ fn aiur_fn_576( 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_539] = { let __args: [G; IN_539] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -47460,8 +47540,8 @@ fn aiur_fn_576( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_576] = [__v_16]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_16]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47476,15 +47556,15 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 12; -const IN_577: usize = 12; -const OUT_577: usize = 1; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_578: usize = 12; +const IN_578: usize = 12; +const OUT_578: usize = 1; +fn aiur_fn_578( + inp: [G; IN_578], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_577], 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]; @@ -47503,7 +47583,7 @@ fn aiur_fn_577( 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_539] = { let __args: [G; IN_539] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -47522,16 +47602,16 @@ fn aiur_fn_577( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_577] = [__v_24]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_24]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_577] = [__v_28]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_28]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47540,8 +47620,8 @@ fn aiur_fn_577( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_577] = [__v_22]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_22]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47550,23 +47630,23 @@ fn aiur_fn_577( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_577] = [__v_14]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_14]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_578: usize = 6; -const IN_578: usize = 6; -const OUT_578: usize = 1; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_579: usize = 6; +const IN_579: usize = 6; +const OUT_579: usize = 1; +fn aiur_fn_579( + inp: [G; IN_579], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_578], 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]; @@ -47577,7 +47657,7 @@ fn aiur_fn_578( 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_539] = { let __args: [G; IN_539] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -47589,14 +47669,14 @@ fn aiur_fn_578( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __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_579] = { let __args: [G; IN_579] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_578] = [__v_19]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_579] = [__v_19]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47606,15 +47686,15 @@ fn aiur_fn_578( }) } -const INPUT_SIZE_579: usize = 2; -const IN_579: usize = 2; -const OUT_579: usize = 1; -fn aiur_fn_579( - inp: [G; IN_579], +const INPUT_SIZE_580: usize = 2; +const IN_580: usize = 2; +const OUT_580: usize = 1; +fn aiur_fn_580( + inp: [G; IN_580], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_579], ExecError> { +) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47627,13 +47707,13 @@ fn aiur_fn_579( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_579] = [__v_7]; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_580] = [__v_7]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -47641,13 +47721,13 @@ fn aiur_fn_579( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_579] = [__v_12]; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_580] = [__v_12]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47657,15 +47737,15 @@ fn aiur_fn_579( }) } -const INPUT_SIZE_580: usize = 3; -const IN_580: usize = 3; -const OUT_580: usize = 1; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_581: usize = 3; +const IN_581: usize = 3; +const OUT_581: usize = 1; +fn aiur_fn_581( + inp: [G; IN_581], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], 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]; @@ -47676,8 +47756,8 @@ fn aiur_fn_580( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_580] = [__v_6]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_6]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47688,26 +47768,26 @@ fn aiur_fn_580( let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_580] = [__v_12]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_12]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_581: usize = 2; -const IN_581: usize = 2; -const OUT_581: usize = 1; -fn aiur_fn_581( - inp: [G; IN_581], +const INPUT_SIZE_582: usize = 2; +const IN_582: usize = 2; +const OUT_582: usize = 1; +fn aiur_fn_582( + inp: [G; IN_582], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_581], ExecError> { +) -> Result<[G; OUT_582], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47765,10 +47845,10 @@ fn aiur_fn_581( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_581] = [__v_51]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_51]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47790,7 +47870,7 @@ fn aiur_fn_581( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); @@ -47801,16 +47881,16 @@ fn aiur_fn_581( let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_581] = [__v_73]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_73]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_581] = [__v_65]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_65]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47821,15 +47901,15 @@ fn aiur_fn_581( }) } -const INPUT_SIZE_582: usize = 5; -const IN_582: usize = 5; -const OUT_582: usize = 1; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_583: usize = 5; +const IN_583: usize = 5; +const OUT_583: usize = 1; +fn aiur_fn_583( + inp: [G; IN_583], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_582], 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]; @@ -47889,8 +47969,8 @@ fn aiur_fn_582( let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_582] = [__v_54]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_54]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -47925,7 +48005,7 @@ fn aiur_fn_582( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); @@ -47934,20 +48014,20 @@ fn aiur_fn_582( let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_582] = [__v_77]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_77]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!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_582] = { let __args: [G; IN_582] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_582] = [__v_54]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_54]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47959,15 +48039,15 @@ fn aiur_fn_582( }) } -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_584: usize = 3; +const IN_584: usize = 3; +const OUT_584: usize = 1; +fn aiur_fn_584( + inp: [G; IN_584], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_583], 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]; @@ -47982,8 +48062,8 @@ fn aiur_fn_583( match __v_3.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_583] = [__v_9]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_9]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -47993,38 +48073,38 @@ fn aiur_fn_583( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_583] = [__v_11]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_11]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_10]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_10]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_9]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_9]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48036,15 +48116,15 @@ fn aiur_fn_583( }) } -const INPUT_SIZE_584: usize = 2; -const IN_584: usize = 2; -const OUT_584: usize = 1; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_585: usize = 2; +const IN_585: usize = 2; +const OUT_585: usize = 1; +fn aiur_fn_585( + inp: [G; IN_585], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_584], 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]; @@ -48052,8 +48132,8 @@ fn aiur_fn_584( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_584] = [__v_3]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_3]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48075,22 +48155,22 @@ fn aiur_fn_584( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48103,16 +48183,16 @@ fn aiur_fn_584( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48129,24 +48209,24 @@ fn aiur_fn_584( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48159,28 +48239,28 @@ fn aiur_fn_584( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48193,28 +48273,28 @@ fn aiur_fn_584( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48227,28 +48307,28 @@ fn aiur_fn_584( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48261,40 +48341,40 @@ fn aiur_fn_584( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_13]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_13]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_13]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_13]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48307,16 +48387,16 @@ fn aiur_fn_584( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48336,32 +48416,32 @@ fn aiur_fn_584( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_13]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_13]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_13]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_13]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_12]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_11]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_11]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48375,15 +48455,15 @@ fn aiur_fn_584( }) } -const INPUT_SIZE_585: usize = 2; -const IN_585: usize = 2; -const OUT_585: usize = 1; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_586: usize = 2; +const IN_586: usize = 2; +const OUT_586: usize = 1; +fn aiur_fn_586( + inp: [G; IN_586], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_585], 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]; @@ -48400,14 +48480,14 @@ fn aiur_fn_585( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_585] = [__v_8]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_8]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_8]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_8]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48420,25 +48500,25 @@ fn aiur_fn_585( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_8]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_8]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_9]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_9]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_585] = [__v_9]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_9]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48455,15 +48535,15 @@ fn aiur_fn_585( }) } -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_587: usize = 2; +const IN_587: usize = 2; +const OUT_587: usize = 1; +fn aiur_fn_587( + inp: [G; IN_587], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_586], ExecError> { +) -> Result<[G; OUT_587], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48480,14 +48560,14 @@ fn aiur_fn_586( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_586] = [__v_8]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_8]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_586] = [__v_8]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_8]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48500,25 +48580,25 @@ fn aiur_fn_586( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_586] = [__v_8]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_8]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_586] = [__v_9]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_9]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_586] = [__v_9]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_9]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48535,15 +48615,15 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 13; -const IN_587: usize = 13; -const OUT_587: usize = 1; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_588: usize = 13; +const IN_588: usize = 13; +const OUT_588: usize = 1; +fn aiur_fn_588( + inp: [G; IN_588], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], ExecError> { +) -> Result<[G; OUT_588], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48560,33 +48640,33 @@ fn aiur_fn_587( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_587] = [__v_13]; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_13]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_587] = [__v_15]; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_15]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_588: usize = 2; -const IN_588: usize = 2; -const OUT_588: usize = 1; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_589: usize = 2; +const IN_589: usize = 2; +const OUT_589: usize = 1; +fn aiur_fn_589( + inp: [G; IN_589], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], 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]; @@ -48644,15 +48724,15 @@ fn aiur_fn_588( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_588] = [__v_51]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_51]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_588] = [__v_1]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_1]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48661,15 +48741,15 @@ fn aiur_fn_588( }) } -const INPUT_SIZE_589: usize = 5; -const IN_589: usize = 5; -const OUT_589: usize = 1; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_590: usize = 5; +const IN_590: usize = 5; +const OUT_590: usize = 1; +fn aiur_fn_590( + inp: [G; IN_590], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_589], ExecError> { +) -> Result<[G; OUT_590], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48726,8 +48806,8 @@ fn aiur_fn_589( let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_589] = [__v_4]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = [__v_4]; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -48752,7 +48832,7 @@ fn aiur_fn_589( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; @@ -48771,20 +48851,20 @@ fn aiur_fn_589( let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_589] = [__v_75]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = [__v_75]; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_589] = [__v_4]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = [__v_4]; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_589] = [__v_4]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = [__v_4]; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48792,10 +48872,10 @@ fn aiur_fn_589( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_589] = [__v_54]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = [__v_54]; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48807,51 +48887,51 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 3; -const IN_590: usize = 3; -const OUT_590: usize = 1; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_591: usize = 3; +const IN_591: usize = 3; +const OUT_591: usize = 1; +fn aiur_fn_591( + inp: [G; IN_591], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], 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 __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_590] = [__v_4]; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_4]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_590] = [__v_6]; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_6]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_591: usize = 4; -const IN_591: usize = 4; -const OUT_591: usize = 1; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_592: usize = 4; +const IN_592: usize = 4; +const OUT_592: usize = 1; +fn aiur_fn_592( + inp: [G; IN_592], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_591], 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]; @@ -48911,15 +48991,15 @@ fn aiur_fn_591( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __ret: [G; OUT_591] = [__v_53]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_53]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_591] = [__v_3]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_3]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48928,15 +49008,15 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 7; -const IN_592: usize = 7; -const OUT_592: usize = 1; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_593: usize = 7; +const IN_593: usize = 7; +const OUT_593: usize = 1; +fn aiur_fn_593( + inp: [G; IN_593], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_592], 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]; @@ -48995,8 +49075,8 @@ fn aiur_fn_592( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_592] = [__v_5]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_5]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -49021,7 +49101,7 @@ fn aiur_fn_592( 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_576] = { let __args: [G; IN_576] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; @@ -49082,39 +49162,39 @@ fn aiur_fn_592( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_75]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_75]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __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_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_78]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_78]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __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_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_80]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_80]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49124,10 +49204,10 @@ fn aiur_fn_592( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_56]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = [__v_56]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49139,15 +49219,15 @@ fn aiur_fn_592( }) } -const INPUT_SIZE_593: usize = 3; -const IN_593: usize = 3; -const OUT_593: usize = 2; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_594: usize = 3; +const IN_594: usize = 3; +const OUT_594: usize = 2; +fn aiur_fn_594( + inp: [G; IN_594], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_593], 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]; @@ -49163,8 +49243,8 @@ fn aiur_fn_593( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_593] = [__v_9, __v_10]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_9, __v_10]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -49173,18 +49253,18 @@ fn aiur_fn_593( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_593] = [__v_10, __v_2]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_10, __v_2]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!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_593] = { let __args: [G; IN_593] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_593] = [__v_12, __v_13]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_12, __v_13]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49196,15 +49276,15 @@ fn aiur_fn_593( }) } -const INPUT_SIZE_594: usize = 5; -const IN_594: usize = 5; -const OUT_594: usize = 2; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_595: usize = 5; +const IN_595: usize = 5; +const OUT_595: usize = 2; +fn aiur_fn_595( + inp: [G; IN_595], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_594], 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]; @@ -49222,8 +49302,8 @@ fn aiur_fn_594( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_594] = [__v_11, __v_12]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_11, __v_12]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -49244,7 +49324,7 @@ fn aiur_fn_594( 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_586] = { let __args: [G; IN_586] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -49260,18 +49340,18 @@ fn aiur_fn_594( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_594] = [__v_17, __v_4]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_17, __v_4]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!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_594] = { let __args: [G; IN_594] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_594] = [__v_19, __v_20]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_19, __v_20]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49283,15 +49363,15 @@ fn aiur_fn_594( }) } -const INPUT_SIZE_595: usize = 2; -const IN_595: usize = 2; -const OUT_595: usize = 4; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_596: usize = 2; +const IN_596: usize = 2; +const OUT_596: usize = 4; +fn aiur_fn_596( + inp: [G; IN_596], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], 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]; @@ -49344,27 +49424,27 @@ fn aiur_fn_595( let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_595] = [__v_40, __v_41, __v_44, __v_47]; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_596] = [__v_40, __v_41, __v_44, __v_47]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_595] = [__v_3, __v_4, __v_5, __v_6]; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_596] = [__v_3, __v_4, __v_5, __v_6]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!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_595] = { let __args: [G; IN_595] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_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_595] = [__v_10, __v_11, __v_12, __v_13]; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_596] = [__v_10, __v_11, __v_12, __v_13]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49376,15 +49456,15 @@ fn aiur_fn_595( }) } -const INPUT_SIZE_596: usize = 4; -const IN_596: usize = 4; -const OUT_596: usize = 1; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_597: usize = 4; +const IN_597: usize = 4; +const OUT_597: usize = 1; +fn aiur_fn_597( + inp: [G; IN_597], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_596], 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]; @@ -49398,20 +49478,20 @@ fn aiur_fn_596( let __v_7: G = (__v_6 - __v_0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_596] = [__v_9]; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_597] = [__v_9]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_6]; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_597] = [__v_6]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49421,8 +49501,8 @@ fn aiur_fn_596( let __v_9: G = (__v_8 - __v_0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_596] = [__v_11]; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_597] = [__v_11]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49431,15 +49511,15 @@ fn aiur_fn_596( }) } -const INPUT_SIZE_597: usize = 6; -const IN_597: usize = 6; -const OUT_597: usize = 1; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_598: usize = 6; +const IN_598: usize = 6; +const OUT_598: usize = 1; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_597], 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]; @@ -49449,8 +49529,8 @@ fn aiur_fn_597( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_597] = [__v_0]; - record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_598] = [__v_0]; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49461,19 +49541,19 @@ fn aiur_fn_597( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_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_597] = { let __args: [G; IN_597] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_597] = [__v_17]; - record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_598] = [__v_17]; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49485,15 +49565,15 @@ fn aiur_fn_597( }) } -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_599: usize = 2; +const IN_599: usize = 2; +const OUT_599: usize = 1; +fn aiur_fn_599( + inp: [G; IN_599], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_598], 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]; @@ -49502,8 +49582,8 @@ fn aiur_fn_598( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_598] = [__v_4]; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_599] = [__v_4]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49517,11 +49597,11 @@ fn aiur_fn_598( 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_598] = { let __args: [G; IN_598] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_598] = [__v_10]; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_599] = [__v_10]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49533,15 +49613,15 @@ fn aiur_fn_598( }) } -const INPUT_SIZE_599: usize = 4; -const IN_599: usize = 4; -const OUT_599: usize = 1; -fn aiur_fn_599( - inp: [G; IN_599], +const INPUT_SIZE_600: usize = 4; +const IN_600: usize = 4; +const OUT_600: usize = 1; +fn aiur_fn_600( + inp: [G; IN_600], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_599], 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]; @@ -49550,8 +49630,8 @@ fn aiur_fn_599( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_599] = [__v_0]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_600] = [__v_0]; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49567,25 +49647,25 @@ fn aiur_fn_599( let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_599] = [__v_17]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_600] = [__v_17]; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_600: usize = 3; -const IN_600: usize = 3; -const OUT_600: usize = 1; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_601: usize = 3; +const IN_601: usize = 3; +const OUT_601: usize = 1; +fn aiur_fn_601( + inp: [G; IN_601], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_600], 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]; @@ -49596,21 +49676,21 @@ fn aiur_fn_600( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_600] = [__v_0]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_601] = [__v_0]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_11]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_601] = [__v_11]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49620,15 +49700,15 @@ fn aiur_fn_600( }) } -const INPUT_SIZE_601: usize = 5; -const IN_601: usize = 5; -const OUT_601: usize = 1; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_602: usize = 5; +const IN_602: usize = 5; +const OUT_602: usize = 1; +fn aiur_fn_602( + inp: [G; IN_602], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_601], 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]; @@ -49638,32 +49718,32 @@ fn aiur_fn_601( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_601] = [__v_6]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_6]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_601] = [__v_5]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_5]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_602: usize = 3; -const IN_602: usize = 3; -const OUT_602: usize = 1; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_603: usize = 3; +const IN_603: usize = 3; +const OUT_603: usize = 1; +fn aiur_fn_603( + inp: [G; IN_603], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_602], 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]; @@ -49671,8 +49751,8 @@ fn aiur_fn_602( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_602] = [__v_0]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_603] = [__v_0]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49687,25 +49767,25 @@ fn aiur_fn_602( let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_2 + __v_13); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_15]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_603] = [__v_15]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_603: usize = 2; -const IN_603: usize = 2; -const OUT_603: usize = 1; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_604: usize = 2; +const IN_604: usize = 2; +const OUT_604: usize = 1; +fn aiur_fn_604( + inp: [G; IN_604], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_603], 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]; @@ -49715,18 +49795,18 @@ fn aiur_fn_603( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_603] = [__v_0]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_604] = [__v_0]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_603] = [__v_8]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_604] = [__v_8]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49736,15 +49816,15 @@ fn aiur_fn_603( }) } -const INPUT_SIZE_604: usize = 2; -const IN_604: usize = 2; -const OUT_604: usize = 2; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_605: usize = 2; +const IN_605: usize = 2; +const OUT_605: usize = 2; +fn aiur_fn_605( + inp: [G; IN_605], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], 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]; @@ -49753,8 +49833,8 @@ fn aiur_fn_604( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_604] = [__v_4, __v_0]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_605] = [__v_4, __v_0]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49767,20 +49847,20 @@ fn aiur_fn_604( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_604] = [__v_11, __v_9]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_605] = [__v_11, __v_9]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -49791,21 +49871,21 @@ fn aiur_fn_604( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_604] = [__v_19, __v_17]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_605] = [__v_19, __v_17]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_604] = [__v_16, __v_0]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_605] = [__v_16, __v_0]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49816,15 +49896,15 @@ fn aiur_fn_604( }) } -const INPUT_SIZE_605: usize = 3; -const IN_605: usize = 3; -const OUT_605: usize = 1; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_606: usize = 3; +const IN_606: usize = 3; +const OUT_606: usize = 1; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_605], 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]; @@ -49838,21 +49918,21 @@ fn aiur_fn_605( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_605] = [__v_8]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_606] = [__v_8]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_605] = [__v_11]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_606] = [__v_11]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49862,15 +49942,15 @@ fn aiur_fn_605( }) } -const INPUT_SIZE_606: usize = 6; -const IN_606: usize = 6; -const OUT_606: usize = 1; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_607: usize = 6; +const IN_607: usize = 6; +const OUT_607: usize = 1; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], 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]; @@ -49880,33 +49960,33 @@ fn aiur_fn_606( let __v_5: G = inp[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_6]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_607] = [__v_6]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_7]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_607] = [__v_7]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_607: usize = 3; -const IN_607: usize = 3; -const OUT_607: usize = 1; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_608: usize = 3; +const IN_608: usize = 3; +const OUT_608: usize = 1; +fn aiur_fn_608( + inp: [G; IN_608], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], 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]; @@ -49914,8 +49994,8 @@ fn aiur_fn_607( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_607] = [__v_0]; - record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_608] = [__v_0]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49928,25 +50008,25 @@ fn aiur_fn_607( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_607] = [__v_13]; - record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_608] = [__v_13]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_608: usize = 9; -const IN_608: usize = 9; -const OUT_608: usize = 1; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_609: usize = 9; +const IN_609: usize = 9; +const OUT_609: usize = 1; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], 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]; @@ -49957,20 +50037,20 @@ fn aiur_fn_608( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_15, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_15, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -49978,45 +50058,45 @@ fn aiur_fn_608( let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_608] = [__v_25]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_25]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_609: usize = 3; -const IN_609: usize = 3; -const OUT_609: usize = 1; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_610: usize = 3; +const IN_610: usize = 3; +const OUT_610: usize = 1; +fn aiur_fn_610( + inp: [G; IN_610], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], 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 = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_609] = [__v_4]; - record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_610: usize = 4; -const IN_610: usize = 4; -const OUT_610: usize = 1; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_611: usize = 4; +const IN_611: usize = 4; +const OUT_611: usize = 1; +fn aiur_fn_611( + inp: [G; IN_611], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_610], 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]; @@ -50025,8 +50105,8 @@ fn aiur_fn_610( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_610] = [__v_0]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_0]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50039,25 +50119,25 @@ fn aiur_fn_610( let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_14]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_14]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_611: usize = 2; -const IN_611: usize = 2; -const OUT_611: usize = 1; -fn aiur_fn_611( - inp: [G; IN_611], +const INPUT_SIZE_612: usize = 2; +const IN_612: usize = 2; +const OUT_612: usize = 1; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_611], 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]; @@ -50067,18 +50147,18 @@ fn aiur_fn_611( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_611] = [__v_0]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_0]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_611] = [__v_8]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_8]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50088,15 +50168,15 @@ fn aiur_fn_611( }) } -const INPUT_SIZE_612: usize = 9; -const IN_612: usize = 9; -const OUT_612: usize = 1; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_613: usize = 9; +const IN_613: usize = 9; +const OUT_613: usize = 1; +fn aiur_fn_613( + inp: [G; IN_613], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_612], 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]; @@ -50108,7 +50188,7 @@ fn aiur_fn_612( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -50130,32 +50210,32 @@ fn aiur_fn_612( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_612] = [__v_27]; - record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_27]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_612] = [__v_27]; - record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_27]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_613: usize = 11; -const IN_613: usize = 11; -const OUT_613: usize = 1; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_614: usize = 11; +const IN_614: usize = 11; +const OUT_614: usize = 1; +fn aiur_fn_614( + inp: [G; IN_614], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_613], 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]; @@ -50168,29 +50248,29 @@ fn aiur_fn_613( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_16, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_16, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_11 + __v_19); let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __r_arr[2]; @@ -50205,10 +50285,10 @@ fn aiur_fn_613( let __v_35: G = (__v_33 - __v_34); let __v_36: G = (__v_11 + __v_19); let __v_37: G = (__v_36 + __v_5); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_30, __v_4, __v_35, __v_37, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_30, __v_4, __v_35, __v_37, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_38, __v_5, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_38, __v_5, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __v_42: G = (__v_33 + __v_41); @@ -50220,7 +50300,7 @@ fn aiur_fn_613( let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_49, __v_5, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_49, __v_5, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(3); let __v_53: G = G::from_u64(0); @@ -50232,29 +50312,29 @@ fn aiur_fn_613( let __v_59: G = G::from_u64(5); let __v_60: G = G::from_u64(0); let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_61, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_61, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_62, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_62, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_63, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_63, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_64, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_64, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_65]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_65]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_614: usize = 26; -const IN_614: usize = 26; -const OUT_614: usize = 0; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_615: usize = 26; +const IN_615: usize = 26; +const OUT_615: usize = 0; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_614], 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]; @@ -50340,9 +50420,9 @@ fn aiur_fn_614( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_44.as_canonical_u64() { 1u64 => { @@ -50362,17 +50442,17 @@ fn aiur_fn_614( }; let __v_45: G = __mc_out___mc_1[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_10, __v_20, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_10, __v_20, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_48, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -50382,7 +50462,7 @@ fn aiur_fn_614( let __v_57: G = (__v_51 * __v_56); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_57.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; break '__mc_2 [__v_58]; }, @@ -50396,26 +50476,26 @@ fn aiur_fn_614( }; let __v_58: G = __mc_out___mc_2[0]; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_48, __v_25, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_48, __v_25, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; match __v_60.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_614] = []; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_615] = []; + record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_48, __v_25, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_48, __v_25, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; match __v_63.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_614] = []; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_615] = []; + record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50426,8 +50506,8 @@ fn aiur_fn_614( } }, _ => { - let __ret: [G; OUT_614] = []; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_615] = []; + record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50439,15 +50519,15 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 18; -const IN_615: usize = 18; -const OUT_615: usize = 0; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_616: usize = 18; +const IN_616: usize = 18; +const OUT_616: usize = 0; +fn aiur_fn_616( + inp: [G; IN_616], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_615], 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]; @@ -50467,45 +50547,45 @@ fn aiur_fn_615( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_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_612] = { let __args: [G; IN_612] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_2, __v_24, __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_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_24, __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_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); } let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_615] = []; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_616] = []; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_616: usize = 3; -const IN_616: usize = 3; -const OUT_616: usize = 1; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_617: usize = 3; +const IN_617: usize = 3; +const OUT_617: usize = 1; +fn aiur_fn_617( + inp: [G; IN_617], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], 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]; @@ -50514,8 +50594,8 @@ fn aiur_fn_616( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_616] = [__v_4]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_4]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50529,8 +50609,8 @@ fn aiur_fn_616( match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_616] = [__v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_10]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -50562,11 +50642,11 @@ fn aiur_fn_616( 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_616] = { let __args: [G; IN_616] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); - let __ret: [G; OUT_616] = [__v_27]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_27]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50578,15 +50658,15 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 15; -const IN_617: usize = 15; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_618: usize = 15; +const IN_618: usize = 15; +const OUT_618: usize = 1; +fn aiur_fn_618( + inp: [G; IN_618], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_617], 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]; @@ -50609,8 +50689,8 @@ fn aiur_fn_617( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_617] = [__v_18]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = [__v_18]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50632,24 +50712,24 @@ fn aiur_fn_617( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __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_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_617] = [__v_35]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = [__v_35]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_617] = [__v_31]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = [__v_31]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50658,15 +50738,15 @@ fn aiur_fn_617( }) } -const INPUT_SIZE_618: usize = 9; -const IN_618: usize = 9; -const OUT_618: usize = 0; -fn aiur_fn_618( - inp: [G; IN_618], +const INPUT_SIZE_619: usize = 9; +const IN_619: usize = 9; +const OUT_619: usize = 0; +fn aiur_fn_619( + inp: [G; IN_619], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_618], 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]; @@ -50685,8 +50765,8 @@ fn aiur_fn_618( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_618] = []; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = []; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -50733,8 +50813,8 @@ fn aiur_fn_618( let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_618] = []; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = []; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -50745,7 +50825,7 @@ fn aiur_fn_618( let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -50755,7 +50835,7 @@ fn aiur_fn_618( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -50763,9 +50843,9 @@ fn aiur_fn_618( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_618] = []; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_619] = []; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50782,15 +50862,15 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 12; -const IN_619: usize = 12; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_620: usize = 12; +const IN_620: usize = 12; +const OUT_620: usize = 1; +fn aiur_fn_620( + inp: [G; IN_620], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_619], 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]; @@ -50810,13 +50890,13 @@ fn aiur_fn_619( let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_619] = [__v_0]; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_620] = [__v_0]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -50851,27 +50931,27 @@ fn aiur_fn_619( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __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_719] = { let __args: [G; IN_719] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __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_328] = { let __args: [G; IN_328] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); @@ -50880,30 +50960,30 @@ fn aiur_fn_619( 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_610] = { let __args: [G; IN_610] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_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_610] = { let __args: [G; IN_610] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_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_610] = { let __args: [G; IN_610] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; @@ -50915,22 +50995,22 @@ fn aiur_fn_619( let __v_97: G = G::from_u64(0); let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __ret: [G; OUT_619] = [__v_110]; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_620] = [__v_110]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50940,15 +51020,15 @@ fn aiur_fn_619( }) } -const INPUT_SIZE_620: usize = 13; -const IN_620: usize = 13; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_621: usize = 13; +const IN_621: usize = 13; +const OUT_621: usize = 1; +fn aiur_fn_621( + inp: [G; IN_621], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_620], 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]; @@ -50963,19 +51043,19 @@ fn aiur_fn_620( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); @@ -50988,7 +51068,7 @@ fn aiur_fn_620( let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -51002,26 +51082,26 @@ fn aiur_fn_620( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_49]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_621] = [__v_49]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_621: usize = 3; -const IN_621: usize = 3; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_622: usize = 3; +const IN_622: usize = 3; +const OUT_622: usize = 1; +fn aiur_fn_622( + inp: [G; IN_622], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_621], 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]; @@ -51038,19 +51118,19 @@ fn aiur_fn_621( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_621] = [__v_11]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_622] = [__v_11]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_621] = [__v_12]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_622] = [__v_12]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51060,15 +51140,15 @@ fn aiur_fn_621( }) } -const INPUT_SIZE_622: usize = 5; -const IN_622: usize = 5; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_622], 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]; @@ -51129,15 +51209,15 @@ fn aiur_fn_622( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_54]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_54]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_622] = [__v_4]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_4]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51146,15 +51226,15 @@ fn aiur_fn_622( }) } -const INPUT_SIZE_623: usize = 8; -const IN_623: usize = 8; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_624: usize = 8; +const IN_624: usize = 8; +const OUT_624: usize = 1; +fn aiur_fn_624( + inp: [G; IN_624], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_623], 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]; @@ -51214,8 +51294,8 @@ fn aiur_fn_623( let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_623] = [__v_6]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_6]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -51240,7 +51320,7 @@ fn aiur_fn_623( 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_576] = { let __args: [G; IN_576] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; @@ -51278,9 +51358,9 @@ fn aiur_fn_623( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -51301,17 +51381,17 @@ fn aiur_fn_623( let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_623] = [__v_55]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_55]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!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_623] = { let __args: [G; IN_623] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __ret: [G; OUT_623] = [__v_72]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_72]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51319,10 +51399,10 @@ fn aiur_fn_623( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_623] = [__v_57]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_57]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51334,15 +51414,15 @@ fn aiur_fn_623( }) } -const INPUT_SIZE_624: usize = 1; -const IN_624: usize = 1; -const OUT_624: usize = 1; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_625: usize = 1; +const IN_625: usize = 1; +const OUT_625: usize = 1; +fn aiur_fn_625( + inp: [G; IN_625], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], ExecError> { +) -> Result<[G; OUT_625], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -51357,8 +51437,8 @@ fn aiur_fn_624( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_9]; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_9]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -51389,11 +51469,11 @@ fn aiur_fn_624( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_23]; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_23]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51403,15 +51483,15 @@ fn aiur_fn_624( }) } -const INPUT_SIZE_625: usize = 3; -const IN_625: usize = 3; -const OUT_625: usize = 1; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_626: usize = 3; +const IN_626: usize = 3; +const OUT_626: usize = 1; +fn aiur_fn_626( + inp: [G; IN_626], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_625], 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]; @@ -51452,21 +51532,21 @@ fn aiur_fn_625( let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_625] = [__v_34]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_34]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_626: usize = 15; -const IN_626: usize = 15; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_627: usize = 15; +const IN_627: usize = 15; +const OUT_627: usize = 1; +fn aiur_fn_627( + inp: [G; IN_627], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_626], ExecError> { +) -> Result<[G; OUT_627], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51489,8 +51569,8 @@ fn aiur_fn_626( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_18]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_627] = [__v_18]; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51511,20 +51591,20 @@ fn aiur_fn_626( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __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_626] = { let __args: [G; IN_626] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_37]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_627] = [__v_37]; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51536,15 +51616,15 @@ fn aiur_fn_626( }) } -const INPUT_SIZE_627: usize = 5; -const IN_627: usize = 5; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_628: usize = 5; +const IN_628: usize = 5; +const OUT_628: usize = 1; +fn aiur_fn_628( + inp: [G; IN_628], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_627], 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]; @@ -51553,23 +51633,23 @@ fn aiur_fn_627( let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_7]; - record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_7]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_628: usize = 8; -const IN_628: usize = 8; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_629: usize = 8; +const IN_629: usize = 8; +const OUT_629: usize = 1; +fn aiur_fn_629( + inp: [G; IN_629], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_628], 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]; @@ -51591,8 +51671,8 @@ fn aiur_fn_628( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_628] = [__v_16]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_16]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -51614,28 +51694,28 @@ fn aiur_fn_628( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_628] = { let __args: [G; IN_628] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_34]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_34]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!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_628] = { let __args: [G; IN_628] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_29]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_29]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51647,15 +51727,15 @@ 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_630: usize = 5; +const IN_630: usize = 5; +const OUT_630: usize = 1; +fn aiur_fn_630( + inp: [G; IN_630], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_629], 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]; @@ -51670,23 +51750,23 @@ fn aiur_fn_629( let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_10]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_10]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_9]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_9]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51696,8 +51776,8 @@ fn aiur_fn_629( let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_12]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_12]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51706,15 +51786,15 @@ fn aiur_fn_629( }) } -const INPUT_SIZE_630: usize = 2; -const IN_630: usize = 2; -const OUT_630: usize = 1; -fn aiur_fn_630( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_630], 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]; @@ -51727,30 +51807,30 @@ fn aiur_fn_630( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_8]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_8]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_630] = [__v_1]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_1]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_631: usize = 7; -const IN_631: usize = 7; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_632: usize = 7; +const IN_632: usize = 7; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_631], 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]; @@ -51761,8 +51841,8 @@ fn aiur_fn_631( let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_631] = [__v_0]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_632] = [__v_0]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51773,26 +51853,26 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; 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_631] = { let __args: [G; IN_631] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_18]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_632] = [__v_18]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -51801,19 +51881,19 @@ fn aiur_fn_631( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_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_631] = { let __args: [G; IN_631] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_26]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_632] = [__v_26]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51827,15 +51907,15 @@ fn aiur_fn_631( }) } -const INPUT_SIZE_632: usize = 13; -const IN_632: usize = 13; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_633: usize = 13; +const IN_633: usize = 13; +const OUT_633: usize = 1; +fn aiur_fn_633( + inp: [G; IN_633], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_632], 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]; @@ -51850,13 +51930,13 @@ fn aiur_fn_632( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_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_631] = { let __args: [G; IN_631] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -51868,24 +51948,24 @@ fn aiur_fn_632( let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_107] = { let __args: [G; IN_107] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -51899,61 +51979,61 @@ fn aiur_fn_632( let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_632] = [__v_62]; - record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_62]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_633: usize = 1; -const IN_633: usize = 1; -const OUT_633: usize = 2; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_634: usize = 1; +const IN_634: usize = 1; +const OUT_634: usize = 2; +fn aiur_fn_634( + inp: [G; IN_634], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_633], ExecError> { +) -> Result<[G; OUT_634], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_6, __v_5]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_634] = [__v_6, __v_5]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_634: usize = 2; -const IN_634: usize = 2; -const OUT_634: usize = 2; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_635: usize = 2; +const IN_635: usize = 2; +const OUT_635: usize = 2; +fn aiur_fn_635( + inp: [G; IN_635], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_634], 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]; @@ -51966,31 +52046,31 @@ fn aiur_fn_634( 5u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_634] = [__v_8, __v_9]; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_635] = [__v_8, __v_9]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_634] = [__v_1, __v_0]; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_635] = [__v_1, __v_0]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_635: usize = 8; -const IN_635: usize = 8; -const OUT_635: usize = 1; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_636: usize = 8; +const IN_636: usize = 8; +const OUT_636: usize = 1; +fn aiur_fn_636( + inp: [G; IN_636], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_635], 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]; @@ -52009,30 +52089,30 @@ fn aiur_fn_635( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_635] = [__v_13]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = [__v_13]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __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_719] = { let __args: [G; IN_719] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __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_328] = { let __args: [G; IN_328] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -52046,12 +52126,12 @@ fn aiur_fn_635( let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); @@ -52062,21 +52142,21 @@ fn aiur_fn_635( let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_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_635] = { let __args: [G; IN_635] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_635] = [__v_58]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = [__v_58]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52086,15 +52166,15 @@ fn aiur_fn_635( }) } -const INPUT_SIZE_636: usize = 3; -const IN_636: usize = 3; -const OUT_636: usize = 1; -fn aiur_fn_636( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], 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]; @@ -52108,19 +52188,19 @@ fn aiur_fn_636( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_636] = [__v_8]; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_637] = [__v_8]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_636] = [__v_9]; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_637] = [__v_9]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52130,15 +52210,15 @@ fn aiur_fn_636( }) } -const INPUT_SIZE_637: usize = 4; -const IN_637: usize = 4; -const OUT_637: usize = 1; -fn aiur_fn_637( - inp: [G; IN_637], +const INPUT_SIZE_638: usize = 4; +const IN_638: usize = 4; +const OUT_638: usize = 1; +fn aiur_fn_638( + inp: [G; IN_638], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_637], 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]; @@ -52147,8 +52227,8 @@ fn aiur_fn_637( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_637] = [__v_0]; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_0]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52163,25 +52243,25 @@ fn aiur_fn_637( let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_637] = [__v_16]; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_16]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_638: usize = 6; -const IN_638: usize = 6; -const OUT_638: usize = 1; -fn aiur_fn_638( - inp: [G; IN_638], +const INPUT_SIZE_639: usize = 6; +const IN_639: usize = 6; +const OUT_639: usize = 1; +fn aiur_fn_639( + inp: [G; IN_639], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], 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]; @@ -52194,55 +52274,55 @@ fn aiur_fn_638( 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_610] = { let __args: [G; IN_610] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_638] = [__v_9]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = [__v_9]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_638] = [__v_7]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = [__v_7]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_639: usize = 3; -const IN_639: usize = 3; -const OUT_639: usize = 2; -fn aiur_fn_639( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_639], 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_639] = [__v_3, __v_4]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = [__v_3, __v_4]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -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_641: usize = 3; +const IN_641: usize = 3; +const OUT_641: usize = 2; +fn aiur_fn_641( + inp: [G; IN_641], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_640], 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]; @@ -52250,7 +52330,7 @@ fn aiur_fn_640( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -52259,11 +52339,11 @@ fn aiur_fn_640( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_640] = [__v_11, __v_12]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_11, __v_12]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52278,18 +52358,18 @@ fn aiur_fn_640( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_640] = [__v_18, __v_19]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_18, __v_19]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_640] = [__v_17, __v_18]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_17, __v_18]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52298,15 +52378,15 @@ 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_642: usize = 5; +const IN_642: usize = 5; +const OUT_642: usize = 2; +fn aiur_fn_642( + inp: [G; IN_642], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_641], 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]; @@ -52324,8 +52404,8 @@ 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].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_11, __v_12]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -52337,7 +52417,7 @@ fn aiur_fn_641( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -52348,18 +52428,18 @@ fn aiur_fn_641( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_641] = [__v_14, __v_4]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_14, __v_4]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!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_641] = { let __args: [G; IN_641] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_641] = [__v_16, __v_17]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_16, __v_17]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52371,15 +52451,15 @@ fn aiur_fn_641( }) } -const INPUT_SIZE_642: usize = 3; -const IN_642: usize = 3; -const OUT_642: usize = 1; -fn aiur_fn_642( - inp: [G; IN_642], +const INPUT_SIZE_643: usize = 3; +const IN_643: usize = 3; +const OUT_643: usize = 1; +fn aiur_fn_643( + inp: [G; IN_643], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_642], 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]; @@ -52391,8 +52471,8 @@ fn aiur_fn_642( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_642] = [__v_6]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_6]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -52403,28 +52483,28 @@ fn aiur_fn_642( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_642] = [__v_9]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_9]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_642] = [__v_12]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_12]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_642] = [__v_12]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_12]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52441,15 +52521,15 @@ fn aiur_fn_642( }) } -const INPUT_SIZE_643: usize = 7; -const IN_643: usize = 7; -const OUT_643: usize = 4; -fn aiur_fn_643( - inp: [G; IN_643], +const INPUT_SIZE_644: usize = 7; +const IN_644: usize = 7; +const OUT_644: usize = 4; +fn aiur_fn_644( + inp: [G; IN_644], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_643], 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]; @@ -52466,7 +52546,7 @@ fn aiur_fn_643( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); @@ -52479,53 +52559,53 @@ fn aiur_fn_643( let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __ret: [G; OUT_643] = [__v_22, __v_23, __v_24, __v_25]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_22, __v_23, __v_24, __v_25]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!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_643] = { let __args: [G; IN_643] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __ret: [G; OUT_643] = [__v_18, __v_19, __v_20, __v_21]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_18, __v_19, __v_20, __v_21]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_11, __v_12, __v_13, __v_0]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_11, __v_12, __v_13, __v_0]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_644: usize = 4; -const IN_644: usize = 4; -const OUT_644: usize = 1; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_645: usize = 4; +const IN_645: usize = 4; +const OUT_645: usize = 1; +fn aiur_fn_645( + inp: [G; IN_645], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_644], 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]; @@ -52543,8 +52623,8 @@ fn aiur_fn_644( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_644] = [__v_12]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_645] = [__v_12]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -52565,26 +52645,26 @@ fn aiur_fn_644( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_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_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_644] = [__v_30]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_645] = [__v_30]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_23]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_645] = [__v_23]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52596,15 +52676,15 @@ fn aiur_fn_644( }) } -const INPUT_SIZE_645: usize = 13; -const IN_645: usize = 13; -const OUT_645: usize = 0; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_646: usize = 13; +const IN_646: usize = 13; +const OUT_646: usize = 0; +fn aiur_fn_646( + inp: [G; IN_646], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_645], 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]; @@ -52621,7 +52701,7 @@ fn aiur_fn_645( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -52640,9 +52720,9 @@ fn aiur_fn_645( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -52655,11 +52735,11 @@ fn aiur_fn_645( 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_539] = { let __args: [G; IN_539] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __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_648] = { let __args: [G; IN_648] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -52672,15 +52752,15 @@ fn aiur_fn_645( 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_646] = { let __args: [G; IN_646] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __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()) }); @@ -52688,9 +52768,9 @@ fn aiur_fn_645( 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_614] = { let __args: [G; IN_614] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_645] = []; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52705,15 +52785,15 @@ fn aiur_fn_645( }) } -const INPUT_SIZE_646: usize = 6; -const IN_646: usize = 6; -const OUT_646: usize = 0; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_647: usize = 6; +const IN_647: usize = 6; +const OUT_647: usize = 0; +fn aiur_fn_647( + inp: [G; IN_647], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_646], 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]; @@ -52724,7 +52804,7 @@ fn aiur_fn_646( 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_539] = { let __args: [G; IN_539] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -52736,13 +52816,13 @@ fn aiur_fn_646( let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_646] = []; - record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_647] = []; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52752,15 +52832,15 @@ fn aiur_fn_646( }) } -const INPUT_SIZE_647: usize = 2; -const IN_647: usize = 2; -const OUT_647: usize = 1; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_648: usize = 2; +const IN_648: usize = 2; +const OUT_648: usize = 1; +fn aiur_fn_648( + inp: [G; IN_648], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], 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]; @@ -52770,8 +52850,8 @@ fn aiur_fn_647( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_647] = [__v_5]; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = [__v_5]; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52781,26 +52861,26 @@ fn aiur_fn_647( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_647] = [__v_10]; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = [__v_10]; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_648: usize = 3; -const IN_648: usize = 3; -const OUT_648: usize = 0; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_649: usize = 3; +const IN_649: usize = 3; +const OUT_649: usize = 0; +fn aiur_fn_649( + inp: [G; IN_649], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_648], 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]; @@ -52813,18 +52893,18 @@ fn aiur_fn_648( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_648] = []; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_648] = []; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52836,15 +52916,15 @@ fn aiur_fn_648( }) } -const INPUT_SIZE_649: usize = 4; -const IN_649: usize = 4; -const OUT_649: usize = 3; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_650: usize = 4; +const IN_650: usize = 4; +const OUT_650: usize = 3; +fn aiur_fn_650( + inp: [G; IN_650], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_649], 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]; @@ -52852,8 +52932,8 @@ fn aiur_fn_649( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_649] = [__v_0, __v_2, __v_3]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_0, __v_2, __v_3]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52870,17 +52950,17 @@ fn aiur_fn_649( let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __ret: [G; OUT_649] = [__v_14, __v_15, __v_16]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_14, __v_15, __v_16]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_649] = [__v_0, __v_2, __v_3]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_0, __v_2, __v_3]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52889,15 +52969,15 @@ fn aiur_fn_649( }) } -const INPUT_SIZE_650: usize = 13; -const IN_650: usize = 13; -const OUT_650: usize = 0; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_651: usize = 13; +const IN_651: usize = 13; +const OUT_651: usize = 0; +fn aiur_fn_651( + inp: [G; IN_651], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_650], 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]; @@ -52912,58 +52992,58 @@ fn aiur_fn_650( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __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_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -52972,71 +53052,71 @@ fn aiur_fn_650( let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -53053,24 +53133,24 @@ fn aiur_fn_650( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; 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()) }); } let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53080,17 +53160,17 @@ fn aiur_fn_650( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53100,15 +53180,15 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 1; -const IN_651: usize = 1; -const OUT_651: usize = 0; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_652: usize = 1; +const IN_652: usize = 1; +const OUT_652: usize = 0; +fn aiur_fn_652( + inp: [G; IN_652], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_651], ExecError> { +) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; @@ -53126,22 +53206,22 @@ fn aiur_fn_651( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_652: usize = 1; -const IN_652: usize = 1; -const OUT_652: usize = 1; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_653: usize = 1; +const IN_653: usize = 1; +const OUT_653: usize = 1; +fn aiur_fn_653( + inp: [G; IN_653], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_652], ExecError> { +) -> Result<[G; OUT_653], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -53172,90 +53252,90 @@ fn aiur_fn_652( let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_24]; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_24]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_22]; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_22]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_652] = [__v_21]; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_21]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_652] = [__v_21]; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_21]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_652] = [__v_21]; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_21]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_652] = [__v_23]; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_23]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_21]; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_21]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_653: usize = 1; -const IN_653: usize = 1; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_654: usize = 1; +const IN_654: usize = 1; +const OUT_654: usize = 1; +fn aiur_fn_654( + inp: [G; IN_654], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], ExecError> { +) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -53267,19 +53347,19 @@ fn aiur_fn_653( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_653] = [__v_6]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_6]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_6]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_6]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53289,15 +53369,15 @@ fn aiur_fn_653( }) } -const INPUT_SIZE_654: usize = 1; -const IN_654: usize = 1; -const OUT_654: usize = 1; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_655: usize = 1; +const IN_655: usize = 1; +const OUT_655: usize = 1; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_654], ExecError> { +) -> Result<[G; OUT_655], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -53317,21 +53397,21 @@ fn aiur_fn_654( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_654] = [__v_14]; - record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_655] = [__v_14]; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_654] = [__v_14]; - record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_655] = [__v_14]; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53343,15 +53423,15 @@ fn aiur_fn_654( }) } -const INPUT_SIZE_655: usize = 1; -const IN_655: usize = 1; -const OUT_655: usize = 1; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_656: usize = 1; +const IN_656: usize = 1; +const OUT_656: usize = 1; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_655], ExecError> { +) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -53396,21 +53476,21 @@ fn aiur_fn_655( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_655] = [__v_39]; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = [__v_39]; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_655] = [__v_39]; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = [__v_39]; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53422,15 +53502,15 @@ fn aiur_fn_655( }) } -const INPUT_SIZE_656: usize = 1; -const IN_656: usize = 1; -const OUT_656: usize = 1; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_657: usize = 1; +const IN_657: usize = 1; +const OUT_657: usize = 1; +fn aiur_fn_657( + inp: [G; IN_657], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_656], ExecError> { +) -> Result<[G; OUT_657], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -53486,8 +53566,8 @@ fn aiur_fn_656( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_656] = [__v_50]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_50]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -53495,18 +53575,18 @@ fn aiur_fn_656( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_52]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_52]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53514,18 +53594,18 @@ fn aiur_fn_656( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_52]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_52]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53533,18 +53613,18 @@ fn aiur_fn_656( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_52]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = [__v_52]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53561,15 +53641,15 @@ fn aiur_fn_656( }) } -const INPUT_SIZE_657: usize = 48; -const IN_657: usize = 48; -const OUT_657: usize = 1; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_658: usize = 48; +const IN_658: usize = 48; +const OUT_658: usize = 1; +fn aiur_fn_658( + inp: [G; IN_658], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_657], 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]; @@ -53621,22 +53701,22 @@ fn aiur_fn_657( let __v_47: G = inp[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_52]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_52]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53644,16 +53724,16 @@ fn aiur_fn_657( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_52]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_52]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53661,12 +53741,12 @@ fn aiur_fn_657( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_50]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_50]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53674,28 +53754,28 @@ fn aiur_fn_657( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_50]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_50]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_50]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_50]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_657] = [__v_48]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = [__v_48]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53704,15 +53784,15 @@ fn aiur_fn_657( }) } -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_659: usize = 2; +const IN_659: usize = 2; +const OUT_659: usize = 1; +fn aiur_fn_659( + inp: [G; IN_659], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_658], 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]; @@ -53723,8 +53803,8 @@ fn aiur_fn_658( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_658] = [__v_5]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = [__v_5]; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -53732,15 +53812,15 @@ fn aiur_fn_658( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_658] = [__v_6]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = [__v_6]; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_658] = [__v_6]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = [__v_6]; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53752,15 +53832,15 @@ fn aiur_fn_658( }) } -const INPUT_SIZE_659: usize = 1; -const IN_659: usize = 1; -const OUT_659: usize = 0; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_660: usize = 1; +const IN_660: usize = 1; +const OUT_660: usize = 0; +fn aiur_fn_660( + inp: [G; IN_660], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], ExecError> { +) -> Result<[G; OUT_660], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; @@ -53817,14 +53897,14 @@ fn aiur_fn_659( 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_661] = { let __args: [G; IN_661] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -53832,8 +53912,8 @@ fn aiur_fn_659( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -53841,8 +53921,8 @@ fn aiur_fn_659( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -53850,39 +53930,39 @@ fn aiur_fn_659( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_659] = []; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_660] = []; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_660: usize = 3; -const IN_660: usize = 3; -const OUT_660: usize = 0; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_661: usize = 3; +const IN_661: usize = 3; +const OUT_661: usize = 0; +fn aiur_fn_661( + inp: [G; IN_661], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_660], 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]; @@ -53893,16 +53973,16 @@ fn aiur_fn_660( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_660] = []; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_661] = []; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __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_659] = { let __args: [G; IN_659] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -53912,9 +53992,9 @@ fn aiur_fn_660( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_660] = []; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53924,15 +54004,15 @@ fn aiur_fn_660( }) } -const INPUT_SIZE_661: usize = 4; -const IN_661: usize = 4; -const OUT_661: usize = 0; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_662: usize = 4; +const IN_662: usize = 4; +const OUT_662: usize = 0; +fn aiur_fn_662( + inp: [G; IN_662], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_661], 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]; @@ -53988,17 +54068,17 @@ fn aiur_fn_661( let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_661] = []; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54008,15 +54088,15 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 48; -const IN_662: usize = 48; -const OUT_662: usize = 0; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_663: usize = 48; +const IN_663: usize = 48; +const OUT_663: usize = 0; +fn aiur_fn_663( + inp: [G; IN_663], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], 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]; @@ -54083,22 +54163,22 @@ fn aiur_fn_662( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_662] = []; - record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_663] = []; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_663: usize = 1; -const IN_663: usize = 1; -const OUT_663: usize = 1; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_664: usize = 1; +const IN_664: usize = 1; +const OUT_664: usize = 1; +fn aiur_fn_664( + inp: [G; IN_664], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], ExecError> { +) -> Result<[G; OUT_664], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); @@ -54111,21 +54191,21 @@ fn aiur_fn_663( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_663] = [__v_8]; - record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_664] = [__v_8]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_664: usize = 2; -const IN_664: usize = 2; -const OUT_664: usize = 1; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_665: usize = 2; +const IN_665: usize = 2; +const OUT_665: usize = 1; +fn aiur_fn_665( + inp: [G; IN_665], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], 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]; @@ -54141,21 +54221,21 @@ fn aiur_fn_664( let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_664] = [__v_10]; - record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_665] = [__v_10]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_665: usize = 1; -const IN_665: usize = 1; -const OUT_665: usize = 3; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_666: usize = 1; +const IN_666: usize = 1; +const OUT_666: usize = 3; +fn aiur_fn_666( + inp: [G; IN_666], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], ExecError> { +) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -54166,15 +54246,15 @@ fn aiur_fn_665( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_665] = [__v_5, __v_10, __v_4]; - record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_666] = [__v_5, __v_10, __v_4]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -54214,25 +54294,25 @@ fn aiur_fn_665( let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_665] = [__v_35, __v_38, __v_2]; - record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_666] = [__v_35, __v_38, __v_2]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __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_665] = { let __args: [G; IN_665] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __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_664] = { let __args: [G; IN_664] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_665] = [__v_9, __v_10, __v_8]; - record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_666] = [__v_9, __v_10, __v_8]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54242,15 +54322,15 @@ fn aiur_fn_665( }) } -const INPUT_SIZE_666: usize = 1; -const IN_666: usize = 1; -const OUT_666: usize = 1; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_667: usize = 1; +const IN_667: usize = 1; +const OUT_667: usize = 1; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], ExecError> { +) -> Result<[G; OUT_667], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -54304,7 +54384,7 @@ fn aiur_fn_666( 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_665] = { let __args: [G; IN_665] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -54460,21 +54540,21 @@ fn aiur_fn_666( 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_666] = [__v_49]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_667] = [__v_49]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_667: usize = 7; -const IN_667: usize = 7; -const OUT_667: usize = 6; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_668: usize = 7; +const IN_668: usize = 7; +const OUT_668: usize = 6; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], 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]; @@ -54489,28 +54569,28 @@ fn aiur_fn_667( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_667] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __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_667] = { let __args: [G; IN_667] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __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_667] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54520,15 +54600,15 @@ fn aiur_fn_667( }) } -const INPUT_SIZE_668: usize = 7; -const IN_668: usize = 7; -const OUT_668: usize = 1; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_669: usize = 7; +const IN_669: usize = 7; +const OUT_669: usize = 1; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_668], 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]; @@ -54538,23 +54618,23 @@ fn aiur_fn_668( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_668] = [__v_8]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_8]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_669: usize = 14; -const IN_669: usize = 14; -const OUT_669: usize = 0; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_670: usize = 14; +const IN_670: usize = 14; +const OUT_670: usize = 0; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], 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]; @@ -54570,18 +54650,18 @@ fn aiur_fn_669( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_669] = []; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_670] = []; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!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_668] = { let __args: [G; IN_668] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -54648,14 +54728,14 @@ fn aiur_fn_669( 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_661] = { let __args: [G; IN_661] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -54663,8 +54743,8 @@ fn aiur_fn_669( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -54672,8 +54752,8 @@ fn aiur_fn_669( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -54681,24 +54761,24 @@ fn aiur_fn_669( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_669] = []; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_670] = []; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -54707,15 +54787,15 @@ fn aiur_fn_669( }) } -const INPUT_SIZE_670: usize = 16; -const IN_670: usize = 16; -const OUT_670: usize = 0; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_671: usize = 16; +const IN_671: usize = 16; +const OUT_671: usize = 0; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], 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]; @@ -54739,16 +54819,16 @@ fn aiur_fn_670( let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = []; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = []; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __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_669] = { let __args: [G; IN_669] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -54758,9 +54838,9 @@ fn aiur_fn_670( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_670] = []; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_671] = []; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54770,15 +54850,15 @@ fn aiur_fn_670( }) } -const INPUT_SIZE_671: usize = 13; -const IN_671: usize = 13; -const OUT_671: usize = 0; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_672: usize = 13; +const IN_672: usize = 13; +const OUT_672: usize = 0; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], 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]; @@ -54799,16 +54879,16 @@ fn aiur_fn_671( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_671] = []; - record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_672] = []; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_672] = []; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54818,20 +54898,20 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 3; -const IN_672: usize = 3; -const OUT_672: usize = 0; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_673: usize = 3; +const IN_673: usize = 3; +const OUT_673: usize = 0; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], 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 __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { @@ -54841,7 +54921,7 @@ fn aiur_fn_672( break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -54853,7 +54933,7 @@ fn aiur_fn_672( 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_667] = { let __args: [G; IN_667] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -54862,29 +54942,29 @@ fn aiur_fn_672( 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_667] = { let __args: [G; IN_667] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __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_671] = { let __args: [G; IN_671] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_672] = []; - record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_673] = []; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_673: usize = 1; -const IN_673: usize = 1; -const OUT_673: usize = 3; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_674: usize = 1; +const IN_674: usize = 1; +const OUT_674: usize = 3; +fn aiur_fn_674( + inp: [G; IN_674], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], ExecError> { +) -> Result<[G; OUT_674], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -54894,8 +54974,8 @@ fn aiur_fn_673( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_673] = [__v_3, __v_4, __v_2]; - record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_3, __v_4, __v_2]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -54903,8 +54983,8 @@ fn aiur_fn_673( 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_673] = [__v_5, __v_3, __v_4]; - record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_5, __v_3, __v_4]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54914,15 +54994,15 @@ fn aiur_fn_673( }) } -const INPUT_SIZE_674: usize = 2; -const IN_674: usize = 2; -const OUT_674: usize = 10; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_675: usize = 2; +const IN_675: usize = 2; +const OUT_675: usize = 10; +fn aiur_fn_675( + inp: [G; IN_675], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], 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]; @@ -54930,8 +55010,8 @@ fn aiur_fn_674( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_674] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_675] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54946,23 +55026,23 @@ fn aiur_fn_674( 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_674] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_675] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_675: usize = 2; -const IN_675: usize = 2; -const OUT_675: usize = 3; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_676: usize = 2; +const IN_676: usize = 2; +const OUT_676: usize = 3; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], 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]; @@ -54970,8 +55050,8 @@ fn aiur_fn_675( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_675] = [__v_2, __v_3, __v_1]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__v_2, __v_3, __v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54979,23 +55059,23 @@ fn aiur_fn_675( 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_675] = [__v_4, __v_2, __v_3]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__v_4, __v_2, __v_3]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_676: usize = 2; -const IN_676: usize = 2; -const OUT_676: usize = 3; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_677: usize = 2; +const IN_677: usize = 2; +const OUT_677: usize = 3; +fn aiur_fn_677( + inp: [G; IN_677], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], ExecError> { +) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55003,8 +55083,8 @@ fn aiur_fn_676( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_676] = [__v_2, __v_3, __v_1]; - record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_2, __v_3, __v_1]; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55012,23 +55092,23 @@ fn aiur_fn_676( 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_676] = [__v_4, __v_2, __v_3]; - record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_4, __v_2, __v_3]; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_677: usize = 2; -const IN_677: usize = 2; -const OUT_677: usize = 3; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_678: usize = 2; +const IN_678: usize = 2; +const OUT_678: usize = 3; +fn aiur_fn_678( + inp: [G; IN_678], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], 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]; @@ -55036,8 +55116,8 @@ fn aiur_fn_677( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_677] = [__v_2, __v_3, __v_1]; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_2, __v_3, __v_1]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55048,22 +55128,22 @@ fn aiur_fn_677( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_677] = [__v_4, __v_5, __v_3]; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!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_677] = [__v_4, __v_5, __v_3]; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55075,15 +55155,15 @@ fn aiur_fn_677( }) } -const INPUT_SIZE_678: usize = 2; -const IN_678: usize = 2; -const OUT_678: usize = 3; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_679: usize = 2; +const IN_679: usize = 2; +const OUT_679: usize = 3; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], 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]; @@ -55091,8 +55171,8 @@ fn aiur_fn_678( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_678] = [__v_2, __v_3, __v_1]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__v_2, __v_3, __v_1]; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55103,29 +55183,29 @@ fn aiur_fn_678( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_678] = [__v_4, __v_5, __v_3]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!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_678] = [__v_4, __v_5, __v_3]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!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_678] = [__v_4, __v_5, __v_3]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__v_4, __v_5, __v_3]; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55137,15 +55217,15 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 9; -const IN_679: usize = 9; -const OUT_679: usize = 2; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_680: usize = 9; +const IN_680: usize = 9; +const OUT_680: usize = 2; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], 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]; @@ -55163,8 +55243,8 @@ fn aiur_fn_679( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_679] = [__v_12, __v_0]; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_12, __v_0]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55196,28 +55276,28 @@ fn aiur_fn_679( 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_679] = { let __args: [G; IN_679] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_679] = [__v_39, __v_37]; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_39, __v_37]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_680: usize = 2; -const IN_680: usize = 2; -const OUT_680: usize = 3; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_681: usize = 2; +const IN_681: usize = 2; +const OUT_681: usize = 3; +fn aiur_fn_681( + inp: [G; IN_681], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], 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]; @@ -55225,8 +55305,8 @@ fn aiur_fn_680( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_680] = [__v_2, __v_3, __v_1]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_681] = [__v_2, __v_3, __v_1]; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55240,27 +55320,27 @@ fn aiur_fn_680( 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_679] = { let __args: [G; IN_679] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __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_680] = [__v_13, __v_11, __v_12]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_681] = [__v_13, __v_11, __v_12]; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_681: usize = 1; -const IN_681: usize = 1; -const OUT_681: usize = 41; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_682: usize = 1; +const IN_682: usize = 1; +const OUT_682: usize = 41; +fn aiur_fn_682( + inp: [G; IN_682], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_681], ExecError> { +) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; @@ -55282,11 +55362,11 @@ fn aiur_fn_681( 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_676] = { let __args: [G; IN_676] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -55297,7 +55377,7 @@ fn aiur_fn_681( 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_674] = { let __args: [G; IN_674] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -55308,7 +55388,7 @@ fn aiur_fn_681( 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_674] = { let __args: [G; IN_674] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -55319,7 +55399,7 @@ fn aiur_fn_681( 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_674] = { let __args: [G; IN_674] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -55330,25 +55410,25 @@ fn aiur_fn_681( 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_675] = { let __args: [G; IN_675] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_681] = [__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[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_682: usize = 1; -const IN_682: usize = 1; -const OUT_682: usize = 49; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_683: usize = 1; +const IN_683: usize = 1; +const OUT_683: usize = 49; +fn aiur_fn_683( + inp: [G; IN_683], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], ExecError> { +) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; @@ -55361,7 +55441,7 @@ fn aiur_fn_682( 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_681] = { let __args: [G; IN_681] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -55403,21 +55483,21 @@ fn aiur_fn_682( 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_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__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[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_683: usize = 9; -const IN_683: usize = 9; -const OUT_683: usize = 2; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_684: usize = 9; +const IN_684: usize = 9; +const OUT_684: usize = 2; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], 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]; @@ -55435,12 +55515,12 @@ fn aiur_fn_683( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_683] = [__v_12, __v_0]; - record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_684] = [__v_12, __v_0]; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -55499,28 +55579,28 @@ fn aiur_fn_683( 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_683] = { let __args: [G; IN_683] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_683] = [__v_70, __v_68]; - record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_684] = [__v_70, __v_68]; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_684: usize = 2; -const IN_684: usize = 2; -const OUT_684: usize = 3; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_685: usize = 2; +const IN_685: usize = 2; +const OUT_685: usize = 3; +fn aiur_fn_685( + inp: [G; IN_685], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], 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]; @@ -55528,8 +55608,8 @@ fn aiur_fn_684( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_684] = [__v_2, __v_3, __v_1]; - record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = [__v_2, __v_3, __v_1]; + record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55543,27 +55623,27 @@ fn aiur_fn_684( 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_683] = { let __args: [G; IN_683] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __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_684] = [__v_13, __v_11, __v_12]; - record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = [__v_13, __v_11, __v_12]; + record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_685: usize = 1; -const IN_685: usize = 1; -const OUT_685: usize = 55; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_686: usize = 1; +const IN_686: usize = 1; +const OUT_686: usize = 55; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], ExecError> { +) -> Result<[G; OUT_686], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -55599,15 +55679,15 @@ fn aiur_fn_685( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __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_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __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_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -55618,26 +55698,26 @@ fn aiur_fn_685( 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_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -55648,7 +55728,7 @@ fn aiur_fn_685( 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_674] = { let __args: [G; IN_674] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -55659,7 +55739,7 @@ fn aiur_fn_685( 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_674] = { let __args: [G; IN_674] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -55670,30 +55750,30 @@ fn aiur_fn_685( 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_675] = { let __args: [G; IN_675] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_684] = { let __args: [G; IN_684] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __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_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -55704,7 +55784,7 @@ fn aiur_fn_685( 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_674] = { let __args: [G; IN_674] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -55715,7 +55795,7 @@ fn aiur_fn_685( 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_674] = { let __args: [G; IN_674] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -55726,7 +55806,7 @@ fn aiur_fn_685( 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_674] = { let __args: [G; IN_674] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -55737,7 +55817,7 @@ fn aiur_fn_685( 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_674] = { let __args: [G; IN_674] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -55748,17 +55828,17 @@ fn aiur_fn_685( 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_675] = { let __args: [G; IN_675] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_680] = { let __args: [G; IN_680] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_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_685] = [__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[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55768,15 +55848,15 @@ fn aiur_fn_685( }) } -const INPUT_SIZE_686: usize = 1; -const IN_686: usize = 1; -const OUT_686: usize = 63; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_687: usize = 1; +const IN_687: usize = 1; +const OUT_687: usize = 63; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_687], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; @@ -55789,7 +55869,7 @@ fn aiur_fn_686( 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_685] = { let __args: [G; IN_685] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -55845,21 +55925,21 @@ fn aiur_fn_686( 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_686] = [__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[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_687] = [__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[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_687: usize = 9; -const IN_687: usize = 9; -const OUT_687: usize = 2; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_688: usize = 9; +const IN_688: usize = 9; +const OUT_688: usize = 2; +fn aiur_fn_688( + inp: [G; IN_688], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], 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]; @@ -55877,12 +55957,12 @@ fn aiur_fn_687( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_687] = [__v_12, __v_0]; - record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__v_12, __v_0]; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -55955,28 +56035,28 @@ fn aiur_fn_687( 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_687] = { let __args: [G; IN_687] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_687] = [__v_84, __v_82]; - record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = [__v_84, __v_82]; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_688: usize = 1; -const IN_688: usize = 1; -const OUT_688: usize = 55; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_689: usize = 1; +const IN_689: usize = 1; +const OUT_689: usize = 55; +fn aiur_fn_689( + inp: [G; IN_689], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_688], ExecError> { +) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; @@ -56012,15 +56092,15 @@ fn aiur_fn_688( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __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_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __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_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56031,30 +56111,30 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_675] = { let __args: [G; IN_675] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56065,7 +56145,7 @@ fn aiur_fn_688( 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_674] = { let __args: [G; IN_674] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -56076,7 +56156,7 @@ fn aiur_fn_688( 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_674] = { let __args: [G; IN_674] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -56087,7 +56167,7 @@ fn aiur_fn_688( 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_674] = { let __args: [G; IN_674] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -56098,7 +56178,7 @@ fn aiur_fn_688( 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_674] = { let __args: [G; IN_674] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -56109,25 +56189,25 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_680] = { let __args: [G; IN_680] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -56138,22 +56218,22 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __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_674] = { let __args: [G; IN_674] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -56164,18 +56244,18 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56186,7 +56266,7 @@ fn aiur_fn_688( 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_674] = { let __args: [G; IN_674] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -56197,18 +56277,18 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56219,18 +56299,18 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56241,18 +56321,18 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -56263,14 +56343,14 @@ fn aiur_fn_688( 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_675] = { let __args: [G; IN_675] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { @@ -56292,7 +56372,7 @@ fn aiur_fn_688( 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_687] = { let __args: [G; IN_687] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -56306,8 +56386,8 @@ fn aiur_fn_688( 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_688] = [__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[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = [__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[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56317,15 +56397,15 @@ fn aiur_fn_688( }) } -const INPUT_SIZE_689: usize = 1; -const IN_689: usize = 1; -const OUT_689: usize = 1; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_690: usize = 1; +const IN_690: usize = 1; +const OUT_690: usize = 1; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_689], ExecError> { +) -> Result<[G; OUT_690], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -56354,82 +56434,44 @@ fn aiur_fn_689( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_689] = [__v_23]; - record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_690] = [__v_23]; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_690: usize = 1; -const IN_690: usize = 1; -const OUT_690: usize = 1; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_691: usize = 1; +const IN_691: usize = 1; +const OUT_691: usize = 1; +fn aiur_fn_691( + inp: [G; IN_691], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], ExecError> { +) -> Result<[G; OUT_691], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_690] = [__v_1]; - record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_691] = [__v_1]; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_690] = [__v_1]; - record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_691] = [__v_1]; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_690] = [__v_1]; - record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_691: usize = 3; -const IN_691: usize = 3; -const OUT_691: usize = 0; -fn aiur_fn_691( - inp: [G; IN_691], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> 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]; - match __v_1.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_691] = []; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; - let __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_691] = []; + let __ret: [G; OUT_691] = [__v_1]; record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) @@ -56455,12 +56497,12 @@ fn aiur_fn_692( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __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()) }); + 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_692] = []; record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -56493,12 +56535,12 @@ fn aiur_fn_693( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __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()) }); + 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_693] = []; record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -56531,8 +56573,12 @@ fn aiur_fn_694( 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 __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __v_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_694] = []; record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -56545,8 +56591,8 @@ fn aiur_fn_694( }) } -const INPUT_SIZE_695: usize = 17; -const IN_695: usize = 17; +const INPUT_SIZE_695: usize = 3; +const IN_695: usize = 3; const OUT_695: usize = 0; fn aiur_fn_695( inp: [G; IN_695], @@ -56554,6 +56600,40 @@ fn aiur_fn_695( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!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_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_696: usize = 17; +const IN_696: usize = 17; +const OUT_696: usize = 0; +fn aiur_fn_696( + inp: [G; IN_696], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; @@ -56574,8 +56654,8 @@ fn aiur_fn_695( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_695] = []; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_696] = []; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -56603,8 +56683,8 @@ fn aiur_fn_695( 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_695] = []; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_696] = []; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56614,23 +56694,23 @@ fn aiur_fn_695( }) } -const INPUT_SIZE_696: usize = 3; -const IN_696: usize = 3; -const OUT_696: usize = 0; -fn aiur_fn_696( - inp: [G; IN_696], +const INPUT_SIZE_697: usize = 3; +const IN_697: usize = 3; +const OUT_697: usize = 0; +fn aiur_fn_697( + inp: [G; IN_697], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_696], 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]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_696] = []; - record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_697] = []; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -56796,8 +56876,8 @@ fn aiur_fn_696( 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_696] = []; - record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_697] = []; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56807,27 +56887,27 @@ fn aiur_fn_696( }) } -const INPUT_SIZE_697: usize = 3; -const IN_697: usize = 3; -const OUT_697: usize = 0; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_698: usize = 3; +const IN_698: usize = 3; +const OUT_698: usize = 0; +fn aiur_fn_698( + inp: [G; IN_698], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_697], 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]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_697] = []; - record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -56991,8 +57071,8 @@ fn aiur_fn_697( 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_697] = []; - record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57002,15 +57082,15 @@ fn aiur_fn_697( }) } -const INPUT_SIZE_698: usize = 10; -const IN_698: usize = 10; -const OUT_698: usize = 0; -fn aiur_fn_698( - inp: [G; IN_698], +const INPUT_SIZE_699: usize = 10; +const IN_699: usize = 10; +const OUT_699: usize = 0; +fn aiur_fn_699( + inp: [G; IN_699], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_698], 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]; @@ -57058,8 +57138,8 @@ fn aiur_fn_698( let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_698] = []; - record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57087,7 +57167,7 @@ fn aiur_fn_698( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; 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()) }); } @@ -57145,9 +57225,9 @@ fn aiur_fn_698( 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_698] = { let __args: [G; IN_698] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_698] = []; - record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57166,23 +57246,23 @@ fn aiur_fn_698( }) } -const INPUT_SIZE_699: usize = 3; -const IN_699: usize = 3; -const OUT_699: usize = 0; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_700: usize = 3; +const IN_700: usize = 3; +const OUT_700: usize = 0; +fn aiur_fn_700( + inp: [G; IN_700], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_699], 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]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_699] = []; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_700] = []; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -57194,9 +57274,9 @@ fn aiur_fn_699( 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_698] = { let __args: [G; IN_698] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_699] = []; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_700] = []; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57206,15 +57286,15 @@ fn aiur_fn_699( }) } -const INPUT_SIZE_700: usize = 49; -const IN_700: usize = 49; -const OUT_700: usize = 0; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_701: usize = 49; +const IN_701: usize = 49; +const OUT_701: usize = 0; +fn aiur_fn_701( + inp: [G; IN_701], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_700], 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]; @@ -57265,7 +57345,7 @@ fn aiur_fn_700( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -57304,14 +57384,14 @@ fn aiur_fn_700( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_700] = []; - record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_701] = []; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57320,15 +57400,15 @@ fn aiur_fn_700( }) } -const INPUT_SIZE_701: usize = 2; -const IN_701: usize = 2; -const OUT_701: usize = 0; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_702: usize = 2; +const IN_702: usize = 2; +const OUT_702: usize = 0; +fn aiur_fn_702( + inp: [G; IN_702], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_701], 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]; @@ -57385,15 +57465,15 @@ fn aiur_fn_701( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_701] = []; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_701] = []; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57403,29 +57483,29 @@ fn aiur_fn_701( }) } -const INPUT_SIZE_702: usize = 3; -const IN_702: usize = 3; -const OUT_702: usize = 0; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_703: usize = 3; +const IN_703: usize = 3; +const OUT_703: usize = 0; +fn aiur_fn_703( + inp: [G; IN_703], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_702], 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]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57435,15 +57515,15 @@ fn aiur_fn_702( }) } -const INPUT_SIZE_703: usize = 99; -const IN_703: usize = 99; -const OUT_703: usize = 0; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_704: usize = 99; +const IN_704: usize = 99; +const OUT_704: usize = 0; +fn aiur_fn_704( + inp: [G; IN_704], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], ExecError> { +) -> Result<[G; OUT_704], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57550,13 +57630,13 @@ fn aiur_fn_703( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_703] = []; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_704] = []; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57571,14 +57651,14 @@ fn aiur_fn_703( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_703] = []; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_704] = []; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57593,17 +57673,17 @@ fn aiur_fn_703( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_703] = []; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_704] = []; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57620,15 +57700,15 @@ fn aiur_fn_703( }) } -const INPUT_SIZE_704: usize = 2; -const IN_704: usize = 2; -const OUT_704: usize = 0; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_705: usize = 2; +const IN_705: usize = 2; +const OUT_705: usize = 0; +fn aiur_fn_705( + inp: [G; IN_705], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_704], ExecError> { +) -> Result<[G; OUT_705], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57699,12 +57779,12 @@ fn aiur_fn_704( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -57750,10 +57830,10 @@ fn aiur_fn_704( 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_703] = { let __args: [G; IN_703] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57763,15 +57843,15 @@ fn aiur_fn_704( }) } -const INPUT_SIZE_705: usize = 55; -const IN_705: usize = 55; -const OUT_705: usize = 0; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_706: usize = 55; +const IN_706: usize = 55; +const OUT_706: usize = 0; +fn aiur_fn_706( + inp: [G; IN_706], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_705], ExecError> { +) -> Result<[G; OUT_706], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57885,13 +57965,13 @@ fn aiur_fn_705( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57906,17 +57986,17 @@ fn aiur_fn_705( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57931,11 +58011,11 @@ fn aiur_fn_705( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57950,11 +58030,11 @@ fn aiur_fn_705( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57969,11 +58049,11 @@ fn aiur_fn_705( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -57988,10 +58068,10 @@ fn aiur_fn_705( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -58006,10 +58086,10 @@ fn aiur_fn_705( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -58024,10 +58104,10 @@ fn aiur_fn_705( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -58040,9 +58120,9 @@ fn aiur_fn_705( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58059,41 +58139,41 @@ fn aiur_fn_705( }) } -const INPUT_SIZE_706: usize = 2; -const IN_706: usize = 2; -const OUT_706: usize = 0; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_707: usize = 2; +const IN_707: usize = 2; +const OUT_707: usize = 0; +fn aiur_fn_707( + inp: [G; IN_707], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], ExecError> { +) -> Result<[G; OUT_707], 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_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __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_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_707: usize = 32; -const IN_707: usize = 32; -const OUT_707: usize = 0; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_708: usize = 32; +const IN_708: usize = 32; +const OUT_708: usize = 0; +fn aiur_fn_708( + inp: [G; IN_708], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], ExecError> { +) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58165,23 +58245,23 @@ fn aiur_fn_707( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; match __v_57.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(1); let __v_62: G = G::from_u64(1); - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_60, __v_61, __v_62, __v_62, __v_62, __v_62, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_60, __v_61, __v_62, __v_62, __v_62, __v_62, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; @@ -58191,9 +58271,9 @@ fn aiur_fn_707( let __v_69: G = G::from_u64(1); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_55, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_55, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58205,20 +58285,20 @@ fn aiur_fn_707( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_55, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_55, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -58274,9 +58354,9 @@ fn aiur_fn_707( let __v_109: G = __r_arr[52]; let __v_110: G = __r_arr[53]; let __v_111: G = __r_arr[54]; - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_55, __v_57, __v_58, __v_59, __v_60, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_55, __v_57, __v_58, __v_59, __v_60, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { @@ -58286,9 +58366,9 @@ fn aiur_fn_707( let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_55, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_55, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58298,15 +58378,15 @@ fn aiur_fn_707( }) } -const INPUT_SIZE_708: usize = 32; -const IN_708: usize = 32; -const OUT_708: usize = 0; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_709: usize = 32; +const IN_709: usize = 32; +const OUT_709: usize = 0; +fn aiur_fn_709( + inp: [G; IN_709], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58340,27 +58420,27 @@ fn aiur_fn_708( let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_709: usize = 3; -const IN_709: usize = 3; -const OUT_709: usize = 1; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_710: usize = 3; +const IN_710: usize = 3; +const OUT_710: usize = 1; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -58368,13 +58448,13 @@ fn aiur_fn_709( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_709] = [__v_2]; - record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_710] = [__v_2]; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_709] = [__v_5]; - record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_710] = [__v_5]; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58384,15 +58464,15 @@ fn aiur_fn_709( }) } -const INPUT_SIZE_710: usize = 2; -const IN_710: usize = 2; -const OUT_710: usize = 1; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_711: usize = 2; +const IN_711: usize = 2; +const OUT_711: usize = 1; +fn aiur_fn_711( + inp: [G; IN_711], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], 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]; @@ -58407,17 +58487,17 @@ fn aiur_fn_710( let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_710] = [__v_9]; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_711] = [__v_9]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_710] = [__v_7]; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_711] = [__v_7]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58427,15 +58507,15 @@ fn aiur_fn_710( }) } -const INPUT_SIZE_711: usize = 1; -const IN_711: usize = 1; -const OUT_711: usize = 8; -fn aiur_fn_711( - inp: [G; IN_711], +const INPUT_SIZE_712: usize = 1; +const IN_712: usize = 1; +const OUT_712: usize = 8; +fn aiur_fn_712( + inp: [G; IN_712], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_711], ExecError> { +) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -58459,12 +58539,12 @@ fn aiur_fn_711( 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_711] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_712] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -58482,8 +58562,8 @@ fn aiur_fn_711( 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_711] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_712] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58493,15 +58573,15 @@ fn aiur_fn_711( }) } -const INPUT_SIZE_712: usize = 2; -const IN_712: usize = 2; -const OUT_712: usize = 1; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_713: usize = 2; +const IN_713: usize = 2; +const OUT_713: usize = 1; +fn aiur_fn_713( + inp: [G; IN_713], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], 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]; @@ -58512,17 +58592,17 @@ fn aiur_fn_712( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_712] = [__v_1]; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_713] = [__v_1]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_712] = [__v_8]; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_713] = [__v_8]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58532,15 +58612,15 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 1; -const IN_713: usize = 1; -const OUT_713: usize = 8; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_714: usize = 1; +const IN_714: usize = 1; +const OUT_714: usize = 8; +fn aiur_fn_714( + inp: [G; IN_714], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_713], ExecError> { +) -> Result<[G; OUT_714], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -58557,12 +58637,12 @@ fn aiur_fn_713( 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_713] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -58580,8 +58660,8 @@ fn aiur_fn_713( 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_713] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58591,15 +58671,15 @@ fn aiur_fn_713( }) } -const INPUT_SIZE_714: usize = 8; -const IN_714: usize = 8; -const OUT_714: usize = 1; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_715: usize = 8; +const IN_715: usize = 8; +const OUT_715: usize = 1; +fn aiur_fn_715( + inp: [G; IN_715], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], 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]; @@ -58611,8 +58691,8 @@ fn aiur_fn_714( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_714] = [__v_7]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_715] = [__v_7]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -58633,25 +58713,25 @@ fn aiur_fn_714( 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_714] = { let __args: [G; IN_714] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_714] = [__v_21]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_715] = [__v_21]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_21: G = (__v_0 - __v_3); match __v_21.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_714] = [__v_4]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_715] = [__v_4]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_714] = [__v_22]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_715] = [__v_22]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -58665,37 +58745,37 @@ fn aiur_fn_714( }) } -const INPUT_SIZE_715: usize = 1; -const IN_715: usize = 1; -const OUT_715: usize = 1; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_716: usize = 1; +const IN_716: usize = 1; +const OUT_716: usize = 1; +fn aiur_fn_716( + inp: [G; IN_716], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], ExecError> { +) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_715] = [__v_4]; - record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_716] = [__v_4]; + record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_716: usize = 2; -const IN_716: usize = 2; -const OUT_716: usize = 1; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_717: usize = 2; +const IN_717: usize = 2; +const OUT_717: usize = 1; +fn aiur_fn_717( + inp: [G; IN_717], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], 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]; @@ -58705,17 +58785,17 @@ fn aiur_fn_716( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_716] = [__v_1]; - record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_717] = [__v_1]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_716] = [__v_7]; - record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_717] = [__v_7]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58725,15 +58805,15 @@ fn aiur_fn_716( }) } -const INPUT_SIZE_717: usize = 1; -const IN_717: usize = 1; -const OUT_717: usize = 1; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_718: usize = 1; +const IN_718: usize = 1; +const OUT_718: usize = 1; +fn aiur_fn_718( + inp: [G; IN_718], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], ExecError> { +) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -58743,17 +58823,17 @@ fn aiur_fn_717( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_717] = [__v_4]; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_718] = [__v_4]; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __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_717] = [__v_6]; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_718] = [__v_6]; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58763,15 +58843,15 @@ fn aiur_fn_717( }) } -const INPUT_SIZE_718: usize = 1; -const IN_718: usize = 1; -const OUT_718: usize = 8; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_719: usize = 1; +const IN_719: usize = 1; +const OUT_719: usize = 8; +fn aiur_fn_719( + inp: [G; IN_719], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_718], ExecError> { +) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -58821,12 +58901,12 @@ fn aiur_fn_718( 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_718] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_719] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -58844,8 +58924,8 @@ fn aiur_fn_718( 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_718] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_719] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58855,19 +58935,19 @@ fn aiur_fn_718( }) } -const INPUT_SIZE_719: usize = 2; -const IN_719: usize = 2; -const OUT_719: usize = 1; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_720: usize = 2; +const IN_720: usize = 2; +const OUT_720: usize = 1; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_719], 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -58875,8 +58955,8 @@ fn aiur_fn_719( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_719] = [__v_4]; - record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_720] = [__v_4]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58886,15 +58966,15 @@ fn aiur_fn_719( }) } -const INPUT_SIZE_720: usize = 1; -const IN_720: usize = 1; -const OUT_720: usize = 1; -fn aiur_fn_720( - inp: [G; IN_720], +const INPUT_SIZE_721: usize = 1; +const IN_721: usize = 1; +const OUT_721: usize = 1; +fn aiur_fn_721( + inp: [G; IN_721], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_720], ExecError> { +) -> Result<[G; OUT_721], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -58911,17 +58991,17 @@ fn aiur_fn_720( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_720] = [__v_11]; - record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_721] = [__v_11]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __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_720] = [__v_13]; - record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_721] = [__v_13]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58931,15 +59011,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 9; -const IN_721: usize = 9; -const OUT_721: usize = 45; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_722: usize = 9; +const IN_722: usize = 9; +const OUT_722: usize = 45; +fn aiur_fn_722( + inp: [G; IN_722], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], 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]; @@ -59004,8 +59084,8 @@ fn aiur_fn_721( let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_721] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -59018,7 +59098,7 @@ fn aiur_fn_721( 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_721] = { let __args: [G; IN_721] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -59064,8 +59144,8 @@ fn aiur_fn_721( 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_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__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[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59080,15 +59160,15 @@ fn aiur_fn_721( }) } -const INPUT_SIZE_722: usize = 1; -const IN_722: usize = 1; -const OUT_722: usize = 8; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_723: usize = 1; +const IN_723: usize = 1; +const OUT_723: usize = 8; +fn aiur_fn_723( + inp: [G; IN_723], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], ExecError> { +) -> Result<[G; OUT_723], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -59149,12 +59229,12 @@ fn aiur_fn_722( 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_722] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_723] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -59172,8 +59252,8 @@ fn aiur_fn_722( 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_722] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_723] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59183,15 +59263,15 @@ fn aiur_fn_722( }) } -const INPUT_SIZE_723: usize = 1; -const IN_723: usize = 1; -const OUT_723: usize = 8; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_724: usize = 1; +const IN_724: usize = 1; +const OUT_724: usize = 8; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_723], ExecError> { +) -> Result<[G; OUT_724], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -59216,12 +59296,12 @@ fn aiur_fn_723( 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_723] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_724] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -59239,8 +59319,8 @@ fn aiur_fn_723( 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_723] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_724] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59250,15 +59330,15 @@ fn aiur_fn_723( }) } -const INPUT_SIZE_724: usize = 9; -const IN_724: usize = 9; -const OUT_724: usize = 34; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_725: usize = 9; +const IN_725: usize = 9; +const OUT_725: usize = 34; +fn aiur_fn_725( + inp: [G; IN_725], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], 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]; @@ -59312,8 +59392,8 @@ fn aiur_fn_724( let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_724] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -59326,7 +59406,7 @@ fn aiur_fn_724( 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_724] = { let __args: [G; IN_724] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -59361,8 +59441,8 @@ fn aiur_fn_724( 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_724] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __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[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59377,15 +59457,15 @@ fn aiur_fn_724( }) } -const INPUT_SIZE_725: usize = 1; -const IN_725: usize = 1; -const OUT_725: usize = 1; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_726: usize = 1; +const IN_726: usize = 1; +const OUT_726: usize = 1; +fn aiur_fn_726( + inp: [G; IN_726], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], ExecError> { +) -> Result<[G; OUT_726], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -59395,14 +59475,14 @@ fn aiur_fn_725( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_725] = [__v_4]; - record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_726] = [__v_4]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_725] = [__v_4]; - record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_726] = [__v_4]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59412,15 +59492,15 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 5; -const IN_726: usize = 5; -const OUT_726: usize = 1; -fn aiur_fn_726( - inp: [G; IN_726], +const INPUT_SIZE_727: usize = 5; +const IN_727: usize = 5; +const OUT_727: usize = 1; +fn aiur_fn_727( + inp: [G; IN_727], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_726], 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]; @@ -59441,17 +59521,17 @@ fn aiur_fn_726( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_726] = [__v_15]; - record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_727] = [__v_15]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_726] = [__v_13]; - record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_727] = [__v_13]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59461,15 +59541,15 @@ fn aiur_fn_726( }) } -const INPUT_SIZE_727: usize = 2; -const IN_727: usize = 2; -const OUT_727: usize = 1; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_728: usize = 2; +const IN_728: usize = 2; +const OUT_728: usize = 1; +fn aiur_fn_728( + inp: [G; IN_728], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], 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]; @@ -59478,8 +59558,8 @@ fn aiur_fn_727( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_727] = [__v_4]; - record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_728] = [__v_4]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59492,11 +59572,11 @@ fn aiur_fn_727( 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_727] = { let __args: [G; IN_727] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_727] = [__v_9]; - record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_728] = [__v_9]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59508,28 +59588,28 @@ fn aiur_fn_727( }) } -const INPUT_SIZE_728: usize = 2; -const IN_728: usize = 2; -const OUT_728: usize = 1; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_729: usize = 2; +const IN_729: usize = 2; +const OUT_729: usize = 1; +fn aiur_fn_729( + inp: [G; IN_729], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_728] = [__v_0]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_0]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -59537,8 +59617,8 @@ fn aiur_fn_728( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_728] = [__v_7]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_7]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59550,15 +59630,15 @@ fn aiur_fn_728( }) } -const INPUT_SIZE_729: usize = 1; -const IN_729: usize = 1; -const OUT_729: usize = 1; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_730: usize = 1; +const IN_730: usize = 1; +const OUT_730: usize = 1; +fn aiur_fn_730( + inp: [G; IN_730], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], ExecError> { +) -> Result<[G; OUT_730], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; @@ -59570,17 +59650,17 @@ fn aiur_fn_729( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_729] = [__v_6]; - record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_730] = [__v_6]; + record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __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_729] = [__v_8]; - record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_730] = [__v_8]; + record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59590,15 +59670,15 @@ fn aiur_fn_729( }) } -const INPUT_SIZE_730: usize = 8; -const IN_730: usize = 8; -const OUT_730: usize = 6; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_731: usize = 8; +const IN_731: usize = 8; +const OUT_731: usize = 6; +fn aiur_fn_731( + inp: [G; IN_731], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], 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]; @@ -59608,7 +59688,7 @@ fn aiur_fn_730( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -59619,8 +59699,8 @@ fn aiur_fn_730( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_730] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_731] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59630,15 +59710,15 @@ fn aiur_fn_730( }) } -const INPUT_SIZE_731: usize = 9; -const IN_731: usize = 9; -const OUT_731: usize = 1; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_732: usize = 9; +const IN_732: usize = 9; +const OUT_732: usize = 1; +fn aiur_fn_732( + inp: [G; IN_732], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], 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]; @@ -59667,17 +59747,17 @@ fn aiur_fn_731( let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_731] = [__v_23]; - record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_23]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_731] = [__v_21]; - record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_21]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59687,15 +59767,15 @@ fn aiur_fn_731( }) } -const INPUT_SIZE_732: usize = 1; -const IN_732: usize = 1; -const OUT_732: usize = 1; -fn aiur_fn_732( - inp: [G; IN_732], +const INPUT_SIZE_733: usize = 1; +const IN_733: usize = 1; +const OUT_733: usize = 1; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], ExecError> { +) -> Result<[G; OUT_733], 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -59708,17 +59788,17 @@ fn aiur_fn_732( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_732] = [__v_7]; - record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__v_7]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __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_732] = [__v_9]; - record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__v_9]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59728,15 +59808,15 @@ fn aiur_fn_732( }) } -const INPUT_SIZE_733: usize = 2; -const IN_733: usize = 2; -const OUT_733: usize = 1; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_734: usize = 2; +const IN_734: usize = 2; +const OUT_734: usize = 1; +fn aiur_fn_734( + inp: [G; IN_734], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_734], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59746,17 +59826,17 @@ fn aiur_fn_733( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_733] = [__v_1]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_734] = [__v_1]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_733] = [__v_7]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_734] = [__v_7]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59766,15 +59846,15 @@ fn aiur_fn_733( }) } -const INPUT_SIZE_734: usize = 8; -const IN_734: usize = 8; -const OUT_734: usize = 6; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_735: usize = 8; +const IN_735: usize = 8; +const OUT_735: usize = 6; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], ExecError> { +) -> Result<[G; OUT_735], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59794,8 +59874,8 @@ fn aiur_fn_734( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_734] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -59816,22 +59896,22 @@ fn aiur_fn_734( 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_734] = { let __args: [G; IN_734] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __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_735] = { let __args: [G; IN_735] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __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_734] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59841,27 +59921,27 @@ fn aiur_fn_734( let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_734] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __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_735] = { let __args: [G; IN_735] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __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_734] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59875,15 +59955,15 @@ fn aiur_fn_734( }) } -const INPUT_SIZE_735: usize = 15; -const IN_735: usize = 15; -const OUT_735: usize = 6; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_736: usize = 15; +const IN_736: usize = 15; +const OUT_736: usize = 6; +fn aiur_fn_736( + inp: [G; IN_736], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], 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]; @@ -59902,38 +59982,38 @@ fn aiur_fn_735( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __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_735] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_736] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_735] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_736] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_736: usize = 14; -const IN_736: usize = 14; -const OUT_736: usize = 6; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_737: usize = 14; +const IN_737: usize = 14; +const OUT_737: usize = 6; +fn aiur_fn_737( + inp: [G; IN_737], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], 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]; @@ -59973,8 +60053,8 @@ fn aiur_fn_736( let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59998,8 +60078,8 @@ fn aiur_fn_736( let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60027,8 +60107,8 @@ fn aiur_fn_736( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60052,8 +60132,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60061,8 +60141,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60072,8 +60152,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60101,8 +60181,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60110,8 +60190,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60121,8 +60201,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60134,8 +60214,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60145,8 +60225,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60178,8 +60258,8 @@ fn aiur_fn_736( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60203,8 +60283,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60212,8 +60292,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60223,8 +60303,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60252,8 +60332,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60261,8 +60341,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60272,8 +60352,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60285,8 +60365,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60296,8 +60376,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60327,8 +60407,8 @@ fn aiur_fn_736( let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60356,8 +60436,8 @@ fn aiur_fn_736( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60381,8 +60461,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60390,8 +60470,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60401,8 +60481,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60430,8 +60510,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60439,8 +60519,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60450,8 +60530,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60463,8 +60543,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60474,8 +60554,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60507,8 +60587,8 @@ fn aiur_fn_736( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60532,8 +60612,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60541,8 +60621,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60552,8 +60632,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60581,8 +60661,8 @@ fn aiur_fn_736( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60590,8 +60670,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60601,8 +60681,8 @@ fn aiur_fn_736( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60614,8 +60694,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60625,8 +60705,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60660,8 +60740,8 @@ fn aiur_fn_736( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60685,8 +60765,8 @@ fn aiur_fn_736( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60694,8 +60774,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60705,8 +60785,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60734,8 +60814,8 @@ fn aiur_fn_736( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60743,8 +60823,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60754,8 +60834,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60767,8 +60847,8 @@ fn aiur_fn_736( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60778,8 +60858,8 @@ fn aiur_fn_736( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60811,8 +60891,8 @@ fn aiur_fn_736( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60836,8 +60916,8 @@ fn aiur_fn_736( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60845,8 +60925,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60856,8 +60936,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60885,8 +60965,8 @@ fn aiur_fn_736( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60894,8 +60974,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60905,8 +60985,8 @@ fn aiur_fn_736( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60918,8 +60998,8 @@ fn aiur_fn_736( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60929,8 +61009,8 @@ fn aiur_fn_736( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_736] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64631,6 +64711,11 @@ pub(crate) fn execute_generated( let __out = aiur_fn_736(__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)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, From 2d59e12c0b033d83bc40cce1ba18b13de03f28f8 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Sat, 8 Aug 2026 02:18:25 +0000 Subject: [PATCH 20/20] =?UTF-8?q?prove:=20closure-shard=20pipeline=20for?= =?UTF-8?q?=20heavy=20constants=20=E2=80=94=20per-shard=20RAM=20at=20zero?= =?UTF-8?q?=20compute=20cost?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A standalone claim re-derives its whole dependency spine (no frontier): bitblast's closure proved at 473.5 GiB — more than the entire InitStd env shard that contains it plus 6655 neighbors (348 GiB). The fix is to make the closure its own env and partition it: extract → measured union-pricing scan → prove every shard, with thin frontiers internal to the closure, composing to the same unconditional verdict at per-shard RAM. Measured on bitblast (5659-const closure, 495 GB box): standalone 5:43 / 341.8 s compute / 473.5 GiB; 2 shards @480 budget 4:46 / 284.0 s / 325.8 GiB; 9 shards @108 budget 5:40 / 333.5 s / 83.2 GiB — the frontier tax and next_power_of_two padding savings cancel, so splitting is free in wall and total compute while RAM tracks the budget. The 9-shard shape fits the 128 GB CI runner class with margin, and shards prove concurrently (--jobs / a fleet), collapsing wall toward the slowest shard — a RAM-bound serial job becomes parallelizable units. Plumbing: ix prove --ixes --shard grows --json/--json-name (prove-time windowing the FFI trip, peak-rss, proof-size — the rows contract); ix bench run --backend aiur routes heavy-tier Vectors.csv constants through cutAiurClosureShards (extract + scan at the watchdog ceiling, one spawn per shard, /shard-K sub-rows, aggregate parent row that lands only when every shard is green); light tier keeps the single leaf. Strategy, measurements, and caveats in docs/heavy-constant-sharding.md. --- Ix/Cli/BenchCmd.lean | 109 +++++++++++++++++++++++++++++- Ix/Cli/ProveCmd.lean | 29 +++++++- docs/heavy-constant-sharding.md | 115 ++++++++++++++++++++++++++++++++ 3 files changed, 250 insertions(+), 3 deletions(-) create mode 100644 docs/heavy-constant-sharding.md diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean index e52f882e5..4076d8da5 100644 --- a/Ix/Cli/BenchCmd.lean +++ b/Ix/Cli/BenchCmd.lean @@ -658,6 +658,38 @@ def cutClosureShards (ix : String) (envIxe : String) return none return some (subIxe, manifest) +/-- Closure-shard pipeline for aiur heavy-tier constants: extract the + name's dependency closure into a standalone `.ixe`, then cut it with + the MEASURED scan (`ix shard --max-ram`) at the given + budget — no profile step: the scan executes the closure's check + schedule and union-prices the shards. The partition's thin frontiers + are internal to the closure, so checking/proving every shard is an + unconditional verdict on the constant at per-shard RAM instead of + the full-spine re-derivation a standalone `Check` claim pays (473 + GiB measured on bitblast's closure alone). Cached by slug like + [`cutClosureShards`]; `none` ⇒ the caller falls back to a single + leaf. -/ +def cutAiurClosureShards (ix : String) (envIxe : String) + (dir : String) (name : String) (maxRamGb : Nat) : + IO (Option (String × String)) := do + let slug := name.map fun c => + if c == '/' || c == ' ' || c == '.' || c == ':' then '_' else c + let subIxe := s!"{dir}/{slug}.ixe" + let manifest := s!"{dir}/{slug}.ixes" + if (← FilePath.pathExists subIxe) && (← FilePath.pathExists manifest) then + return some (subIxe, manifest) + IO.FS.createDirAll dir + let steps : List (Array String) := + [ #["shard", "extract", envIxe, "--consts", name, "--out", subIxe] + , #["shard", subIxe, "--max-ram", toString maxRamGb, "--out", manifest] ] + for args in steps do + let exit ← runGuarded none 0 ix args + if exit != 0 then + IO.eprintln s!"[bench] closure-shard pipeline failed for '{name}' \ + (exit {exit}); falling back to single leaf" + return none + return some (subIxe, manifest) + /-- Final run gate from the rows themselves: exit 1 when any EXPECTED name lacks a row (an aborted loop, a killed batch, or a dropped whole-env check must never look green — every selected name owes exactly one @@ -881,10 +913,85 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do | "execute" => "execute-time" | "recursive" => "recursive-prove-time" | _ => "prove-time" - runPerConstant out names doneKey fun name => + let leaf := fun name => runGuarded watchdog ceilingGb bt (#["--ixe", ixe, "--consts", name, "--json", out, "--texray"] ++ modeArgs) + -- Heavy tier runs as its closure-shard partition instead of one + -- full-closure leaf: a standalone `Check` claim has no frontier, so + -- the kernel re-derives the constant's whole dependency spine — a + -- record costlier than an entire env shard's (bitblast's closure: + -- 1098 BFFT / 473 GiB proved, vs 348 GiB for the env shard owning + -- it). The closure partition's thin frontiers are internal, so + -- checking/proving all its shards is the same unconditional verdict + -- at per-shard RAM. One sub-row per shard (`/shard-K`); the + -- parent row carries the aggregate (summed time = the serial cost, + -- max RSS, shard count, the manifest's total measured fft). + let heavy := if mode == "recursive" then #[] else + (selected.filter (·.tier == "heavy")).map (·.name) + let light := names.filter (!heavy.contains ·) + runPerConstant out light doneKey leaf + let ix ← resolveBin repo "ix" + for name in heavy do + -- Resume: a complete parent row means every shard already ran. + let rows ← readRows out + if ((rows.getObjVal? name).toOption.bind + fun r => (r.getObjVal? doneKey).toOption).isSome then + continue + match ← cutAiurClosureShards ix ixe s!"{repo}/aiurshards-{env}" name + ceilingGb with + | none => + let _ ← leaf name + | some (subIxe, manifest) => + match Ix.Cli.CheckCmd.parseIxesShards + (← IO.FS.readBinFile manifest) with + | .error e => + IO.eprintln s!"[bench] manifest parse failed for '{name}': {e}" + | .ok shardRows => + let n := shardRows.size + let totalFft := shardRows.foldl (fun s r => s + r.cost) 0 + let sub := if mode == "prove" then "prove" else "check" + let mut greens : Array String := #[] + let mut bad := false + for k in [0:n] do + let rowName := s!"{name}/shard-{k}" + let exit ← runGuarded watchdog ceilingGb ix + #[sub, "--ixe", subIxe, "--ixes", manifest, + "--shard", toString k, "--json", out, + "--json-name", rowName] + if exit == 0 then + greens := greens.push rowName + else if exit ≥ 128 then + let status := killStatus exit + IO.eprintln + s!"[bench] '{rowName}' killed (exit {exit}); recording {status}" + markKilled out rowName status + bad := true + else + IO.eprintln s!"[bench] '{rowName}' failed (exit {exit})" + bad := true + -- The parent row lands only when every shard is green — a + -- partial partition must never look like a complete verdict + -- (the gate then reports the missing parent). + if !bad && greens.size == n then + let rows ← readRows out + let getF (rn key : String) : Option Float := + match ((rows.getObjVal? rn).toOption.bind + fun r => (r.getObjVal? key).toOption) with + | some (.num v) => some v.toFloat + | _ => none + let times := greens.filterMap (getF · doneKey) + let rsss := greens.filterMap (getF · "peak-rss") + let sizes := greens.filterMap (getF · "proof-size") + let mut fields : List (String × Lean.Json) := + [ (doneKey, jsonRound 3 (times.foldl (· + ·) 0.0)) + , ("peak-rss", jsonRound 0 (rsss.foldl max 0.0)) + , ("shards", Lean.toJson n) + , ("fft-cost", Lean.toJson totalFft) ] + if mode == "prove" && sizes.size == n then + fields := fields ++ + [("proof-size", jsonRound 0 (sizes.foldl (· + ·) 0.0))] + writeRow out name "ok" fields | "aiur-recursive" => -- Fixed IxVM statements, resolved in the run's `.ixe`: the same -- spawn as the aiur recursive mode, over `recursiveConstants` diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 2d4f282f0..bfafa2b59 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -127,7 +127,8 @@ def proveOne (aiurSystem : Aiur.AiurSystem) def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) (shards : Array (Array Address)) (shardK : Nat) (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) - (_printStats : Bool) : IO UInt32 := do + (_printStats : Bool) + (benchJson : Option (String × String) := none) : IO UInt32 := do match shards[shardK]? with | none => IO.eprintln s!"shard {shardK} out of range (0..{shards.size})"; return 1 | some blocks => do @@ -138,12 +139,23 @@ def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle) let label := s!"shard {shardK}" IO.println s!"Proving {label}" (← IO.getStdout).flush + -- `benchJson = (out, rowName)` reports the prove as a benchmark row + -- (the `aiur` bench backend's heavy-tier closure-shard spawn): + -- `prove-time` windows the FFI prove itself — env parse, manifest + -- load, and `EnvHandle` build are excluded, matching the check rows' + -- loader-free semantics — while `peak-rss` is the process tree's + -- absolute high-water. + if benchJson.isSome then + TracingTexray.startSampler + TracingTexray.resetPeakTreeRss + let start ← IO.monoMsNow let funIdx := compiled.getFuncIdx `verify_claim |>.get! match aiurSystem.shardProveWithEnv funIdx envHandle blob with | .error e => IO.eprintln s!"{label}: shardProveWithEnv error: {e}" return 1 | .ok (claimBytes, proof, _outIO) => + let ms := (← IO.monoMsNow) - start -- Rust returns the canonical CheckEnv claim's wire bytes; deserialize -- back to `Ix.Claim` to persist alongside the proof. Avoids -- recomputing the closure walk + canonical AssumptionTree Lean-side. @@ -156,6 +168,13 @@ def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle) let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) IO.println (toString proofAddr) + if let some (out, rowName) := benchJson then + let peakRss ← TracingTexray.peakTreeRssBytes + Ix.Benchmark.Results.writeRow out rowName "ok" + [ ("prove-time", + Ix.Benchmark.Results.jsonRound 3 (ms.toFloat / 1000.0)) + , ("peak-rss", Lean.toJson peakRss) + , ("proof-size", Lean.toJson proof.toBytes.size) ] let _ := manifestPath -- kept for parity with previous signature return 0 @@ -366,7 +385,11 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let envHandle ← match Aiur.EnvHandle.fromIxe ixe with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h - runShardProveNative manifest envHandle ixonEnv shards k aiurSystem compiled false + let benchJson := (p.flag? "json").map fun f => + (f.as! String, + ((p.flag? "json-name").map (·.as! String)).getD s!"shard-{k}") + runShardProveNative manifest envHandle ixonEnv shards k aiurSystem + compiled false benchJson | some ixe, some manifest, none => -- Batched, resumable all-shards prove (one env handle + one Aiur -- system across every shard; progress in ~/.ix/cache/shard-proofs). @@ -396,6 +419,8 @@ def proveCmd : Cli.Cmd := `[Cli| "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: prove shard K. Without --shard: prove every shard in the partition." "shard" : Nat; "0-based shard index K (with --ixes and --ixe): prove that one shard's CheckEnv claim." "jobs" : Nat; "Shards to prove concurrently in the all-shards batch (default 1). Each prove peaks at the shard's full predicted RAM, so raise this only when the box fits several shards at once." + json : String; "Benchmark results JSON accumulator (single-shard mode only): append a `prove-time`/`peak-rss`/`proof-size` row for the proved shard. Used by `ix bench run --backend aiur` for heavy-tier closure shards." + "json-name" : String; "Row name for --json (default: shard-)." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to prove. With none, iterate every named constant in the env (sorted)." diff --git a/docs/heavy-constant-sharding.md b/docs/heavy-constant-sharding.md new file mode 100644 index 000000000..836d0468e --- /dev/null +++ b/docs/heavy-constant-sharding.md @@ -0,0 +1,115 @@ +# Heavy constants: closure-shard proving + +Some constants cannot be proved as a single claim on any reasonable +machine. `Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual` +(the ~18B-step bitblast mutual block, 5659 constants in closure) is the +canonical example: its standalone prove measured **473.5 GiB peak** on a +495 GB box and OOM'd the 128 GB CI runner outright. This document +describes why, and the closure-shard strategy that makes such constants +provable at any RAM budget — measured at **no cost in wall clock or +total compute**. + +## Why a standalone prove is the most expensive shape + +A standalone claim (`Claim.check addr none`) carries **no assumptions**: +the kernel must re-derive the constant's entire transitive dependency +spine in-circuit — every definitional unfolding and def-eq down to the +`Nat` primitives. Nothing is shared with any other proof. + +The env partition proves the same constant differently. A shard's +`CheckEnv` claim has a **thin frontier**: dependencies outside the shard +are *assumed* — named by content address and committed in a Merkle tree +(a few blake3 rows each) — not re-checked. Other shards' proofs cover +them, and the composed verdict glues the partition through the coverage +gate (every block owned exactly once, assumption roots matching). + +Measured consequence: bitblast's standalone closure record costs more +than an *entire InitStd env shard* containing bitblast **plus 6655 +neighboring blocks** (473.5 GiB / 5:43 standalone, vs 348.1 GiB / 3:13 +for the whole shard). Hashing a frontier entry costs a few circuit rows; +re-deriving its body costs its whole checking cone. + +## The strategy: shard the closure itself + +Make the closure its own mini-env and partition *it*: + +```bash +ix shard extract env.ixe --consts Foo.bar --out foo.ixe # closure → standalone env +ix shard foo.ixe --max-ram 100 --out foo.ixes # measured union-pricing cut +ix prove --ixe foo.ixe --ixes foo.ixes # prove ALL shards +``` + +The partition's thin frontiers are *internal to the closure*, so proving +every shard yields the same unconditional verdict as the standalone +claim — at per-shard RAM chosen by `--max-ram`. The all-shards prove +shares one env load across shards, verifies each proof and binds it to +its reconstructed claim, and persists progress in +`~/.ix/cache/shard-proofs/` keyed by claim digest — a killed run +resumes, and a repacked manifest re-proves only shards that changed. +`--consts` takes several names (their union closure extracts together); +a mutual-block member extracts its whole block; `--max-ram` defaults to +detected system RAM. + +## Measured: bitblast, three ways (495 GB box, 64 cores) + +| Prove | Wall | Total compute (exec+STARK) | Peak RAM | Proofs | +| ----------------- | ---------- | -------------------------- | ------------- | ----------- | +| Standalone | 5:43 | 341.8 s | **473.5 GiB** | 1 × 23.5 MB | +| 2 shards (@480) | **4:46** | **284.0 s** | 325.8 GiB | 2 × ~24 MB | +| 9 shards (@108) | 5:40 | 333.5 s | **83.2 GiB** | 9 × ~22 MB | + +| Execute | Total kernel time | Peak RAM | +| ----------------- | ----------------- | -------- | +| Standalone | 70.4 s | 25.1 GiB | +| 2 shards (@480) | 69.6 s | 19.0 GiB | +| 9 shards (@108) | 70.9 s | 8.0 GiB | + +Two effects cancel to make splitting free (or better): + +- **Frontier tax**: each shard re-derives frontier-adjacent context its + claim assumes was elsewhere — total work rises with shard count. +- **Padding savings**: trace heights commit at `next_power_of_two`, so + several short records often pad to lower power-of-two boundaries than + one tall record — total work *falls* with shard count. + +At 9 shards these wash (−2% net); at 2 shards padding wins outright +(−17% net, and less wall than standalone). RAM tracks the budget almost +linearly: 473 → 326 → 83 GiB. + +Serial wall is the pessimistic case. The shards are independent proofs: +a fleet of small boxes (or `ix prove --jobs N` on one big box) proves +them concurrently, collapsing wall toward the slowest single shard +(~42 s here). The standalone prove has no such option — it is one +indivisible 473 GiB job. Closure-sharding converts a RAM-bound serial +prove into parallelizable units. + +## CI integration + +`ix bench run --backend aiur` routes **heavy-tier** `Vectors.csv` +constants through this pipeline automatically (`cutAiurClosureShards`: +extract → measured scan at the watchdog ceiling → one +`check`/`prove --shard K` spawn per shard). Each shard reports a +`/shard-K` sub-row; the parent row aggregates (summed time — the +serial cost — max peak-rss, shard count, the manifest's total measured +fft) and lands only when every shard is green. Light-tier constants keep +the single-leaf spawn: cheap closures gain nothing from partition +overhead. + +At the CI runner class (measured at a 108 GiB ceiling) bitblast proves +in 9 shards, 83.2 GiB peak, ~5.7 min serial — inside a 128 GB runner +with margin. Note `(bitblast, aiur, prove)` remains in +`benchExclusions` until a scheduled CI row is wanted; an explicit +`--consts` request always runs. + +## Caveats + +- **N proofs, not one.** The composed verdict is sound, but "a proof of + Foo.bar" is a set of shard proofs until recursive aggregation lands + (9 × ~22 MB vs 1 × 23.5 MB at the fine split). +- The bench cache (`aiurshards-/.{ixe,ixes}`) is keyed by + constant only, not budget: re-cutting at a different ceiling requires + deleting the stale `.ixes` (the extracted `.ixe` is budget-independent + and stays). The raw CLI has no such trap — outputs are named + explicitly. +- A closure that fits the budget in one shard degenerates to exactly the + standalone prove; there is no penalty for trying the pipeline first.